
## Probar AWS SQS localmente

Si se ha usado SQS, es común conectarse a la consola de administración de AWS y configurar el envío de mensajes, sin embargo, no todo es color de rosa. Cuando se tiene que viajar o trabajar en lugares donde la conexión no es muy buena la interacción con la nube puede ser muy molesta. Para estos casos y sobre todo para configurar la integración continua donde se necesita que constantemente se reinicie el entorno para validar que todo funciona como se espera, se hace uso  de docker con las imágenes de [elasticmq](https://hub.docker.com/r/softwaremill/elasticmq)
 (si se desarrolla alguna aplicación con Java posiblemente esta sea la mejor opción) o [localstack](https://hub.docker.com/r/localstack/localstack).

 En lo personal me agrada más localstack ya que cuenta con su propia herramienta de interacción con los servicios y en caso de requerir soporte puedes actualizar a la versión PRO. Para más información puedes consultar su [sitio web](https://localstack.cloud/) (y no me pagan por hacer publicidad).

### Configurando el entorno

Partiendo de un escenario donde se desea desarrollar un sistema con Elixir e interactuar con el servicio de SQS de AWS, se puede practicar el envío y recepción de mensajes. Lo primero es configurar el entorno para que al ejecutar pruebas unitarias se valide que realmente el sistema se comporta como es deseado.

En este caso la integración está pensada con [docker-compose](https://docs.docker.com/compose/compose-file/), primero se genera el archivo `docker-compose.yml` con lo siguiente:

* Si se quiere usar elasticmq:
  ```yaml
  version: "3"
  services:
    elasticmq:
      image: softwaremill/elasticmq-native
      container_name: sqs_elasticmq
      ports:
        - 9324:9324
        - 9325:9325
  ```

* Y lo siguiente si se quiere usar localstack
  ```yaml
  version: "3"
  services:
    sqs:
      image: localstack/localstack
      ports:
        - "4576:4576"
      environment:
        - SERVICES=sqs
        - INIT_SCRIPTS_DIR=/init.d/
        - DEBUG=true
        - DOCKER_HOST=unix:///var/run/docker.sock
      volumes:
        - ./init.d:/init.d
        - "${TMPDIR:-/tmp/localstack}:/tmp/localstack"
  ```

En el caso de elasticmq se habilita el servicio de SQS usando la variable de entorno `SERVICES=sqs`, lo que hace esta imagen muy útil para usar en la integración continua ya que la imagen usa menos espacio y además cuenta con una interfaz sencilla. La interfaz de usuario proporciona información en tiempo real sobre el estado de los mensajes y los atributos de la cola. Por defecto se puede consultar en el puerto 9325.

Para localstack se puede consultar los ejemplos de configuración para la integración continua en la [página oficial](https://docs.localstack.cloud/ci/). Si se desea una interfaz gráfica existe la posibilidad de usar [DynamoDB Admin Web UI](https://www.npmjs.com/package/dynamodb-admin) o [Commandeer desktop app](https://getcommandeer.com/) que es una herramienta de paga pero se ve muy completa. Un punto importante es la asignación del puerto, ya que la herramienta de línea de comandos usará por defecto este puerto y nos ahorra tiempo el evitar poner la url.

Después de esto se puede ejecutar `docker-compose` para descargar las imágenes y levantar los servicios:

```terminal
$ docker-compose up
```

Ahora se puede validar que el servicio está activo con netcat:

```terminal
$ nc -zv 127.0.0.1 4576
Connection to 127.0.0.1 4576 port [tcp/*] succeeded!
```

Hasta este punto solamente se ha iniciado el servicio y está disponible para interactuar con él en un entorno local, el siguiente paso es crear una cola para enviar y recibir mensajes.

## Un script de inicialización de LocalStack

Se puede crear un script para automatizar el proceso de creación de colas, se puede eligir cualquier nombre pero me parece que es descriptivo el uso de `init.d/` como nombre del directorio que contendrá los scripts de inicialización:

```bash
$ mkdir init.d
$ vim init.d/01_init.sh
```

Dentro del archivo se deben agregar las instrucciones para la creación de las colas:

```bash
#!/usr/bin/env bash
set -o errexit
set -o nounset

awslocal sqs create-queue --queue-name="my-local-queue"
```

Hay que recordar que si se tiene el servicio inciiado, debemos detener el servicio e iniciarlo nuevamente:

```terminal
$ docker-compose stop
..
$ docker-compose up 
# alternativa
$ docker-compose restart
```

Después de reiniciar el servicio, para validar que se creó correctamente la cola se puede listar con el comando:

```terminal
$ awslocal sqs list-queues 
{
    "QueueUrls": [
        "http://localhost:4566/000000000000/my-local-queue"
    ]
}
```

Usando la [herramienta de línea de comandos](https://github.com/localstack/localstack) (CLI) de localstack se puede ingresar a la imagen mediante ssh:

```terminal
$ localstack ssh
```

Ahora se puede probar el envío de mensajes usando awslocal:

```terminal
$ awslocal sqs send-message \
   --queue-url http://localhost:4566/000000000000/my-local-queue \
   --message-body '{ "hello":"world" }'

{
    "MD5OfMessageBody": "c1185483306a745058dd47eb96eda313",
    "MessageId": "3bea6f1a-39f8-43a9-b097-cc16a2c0f10b"
}
```

Para leer el mensaje de la cola se puede ejecutar el siguiente comando:

```terminal
$ awslocal sqs receive-message \
   --queue-url http://localhost:4566/000000000000/my-local-queue

{
    "Messages": [
        {
            "MessageId": "3bea6f1a-39f8-43a9-b097-cc16a2c0f10b",
            "ReceiptHandle": "OTY3Mjg2MDUtM2VlYS00MjZiLTg2ZGUtMmU4MTRhNzliM2JlIGFybjphd3M6c3FzOnVzLXdlc3QtMjowMDAwMDAwMDAwMDA6YS1jbWQtcXVldWUgM2JlYTZmMWEtMzlmOC00M2E5LWIwOTctY2MxNmEyYzBmMTBiIDE2NjA3MDEwMTQuNjUwMTA0OA==",
            "MD5OfBody": "df69267381a60e476252c989db9ac8ad",
            "Body": "{ \"hello\":\"world\" }"
        }
    ]
}
```

Si se desea eliminar un mensaje:

```terminal
awslocal sqs delete-message \
  --queue-url http://localhost:4576/123456789012/a-cmd-queue \
  --receipt-handle 'OTY3Mjg2MDUtM2VlYS00MjZiLTg2ZGUtMmU4MTRhNzliM2JlIGFybjphd3M6c3FzOnVzLXdlc3QtMjowMDAwMDAwMDAwMDA6YS1jbWQtcXVldWUgM2JlYTZmMWEtMzlmOC00M2E5LWIwOTctY2MxNmEyYzBmMTBiIDE2NjA3MDEwMTQuNjUwMTA0OA=='
```

Por último, es posible purgar la cola usando el siguiente comando:

```terminal
$ awslocal sqs purge-queue \
   --queue-url http://localhost:4566/000000000000/my-local-queue
```

Para saber más:

* [Amazon Web Services in Action](https://amzn.to/3S39UQ8)
* [Repositorio de ElasticMQ](https://github.com/softwaremill/elasticmq)
* [Repositorios de LocalStack](https://github.com/localstack)
* [Entendiendo LocalStack](https://docs.localstack.cloud/localstack/)
* [Amazon Simple Queue Service](https://aws.amazon.com/sqs/)
* [LocalStack Cloud Developer Tools](https://docs.localstack.cloud/tools/)
* [Cobertura de características del servicio de AWS con localstack](https://docs.localstack.cloud/aws/feature-coverage/)


## Probar AWS SQS localmente

Si se ha usado SQS, es común conectarse a la consola ...


## Tailwind y Phoenix

Tailwind v3 se [se lanzó en diciembre del año pasado](https://tailwindcss.com/blog/tailwindcss-v3) con algunas novedades geniales.  Una de esas características es una nueva CLI Tailwind CSS "autónomo" (standalone) que incluye binarios pre-construidos para todas las plataformas principales.  ¡Esto habilita todas las excelentes características de Tailwind sin la dependencia de `node` o `npm` en el sistema del usuario!

El generador de proyectos **phx.new** agregará soporte para Tailwind en una versión futura, pero agregar Tailwind hoy solo requiere unos pocos pasos rápidos gracias a una nueva [biblioteca de elixir de Tailwind](https://github.com/phoenixframework/tailwind) que el equipo de Phoenix acaba de lanzar.  La biblioteca instala y ejecuta el cliente independiente para su sistema de destino, al igual que el soporte predeterminado de `esbuild` para los nuevos proyectos de Phoenix.

Primero, se agrega la dependencia al archivo `mix.ex`:

```elixir
defp deps do
  [
    ...,
    {:tailwind, "~> 0.1", runtime: Mix.env() == :dev}
  ]
end
```

En el archivo `config.exs`, se establece qué versión de Tailwind CSS se desea usar, la ruta a la configuración de Tailwind y personalizar las rutas de `assets`.

```elixir
config :tailwind, version: "3.1.6", default: [
  args: ~w(
    --config=tailwind.config.js
    --input=css/app.css
    --output=../priv/static/assets/app.css
  ),
  cd: Path.expand("../assets", __DIR__)
]
```

Actualizar el escript de despliegue. Hay que agregar un alias para construir el CSS en el despliegue.

```elixir
defp aliases do
  [
    "assets.deploy": ["tailwind default --minify", "esbuild default --minify", "phx.digest"]
  ]
]
```

Agregar Tailwind a la lista de observadores en el archivo `./config/dev.exs`.

```elixir 
config :my_app, MyAppWeb.Endpoint,
  ...,
  watchers: [
    ...,
    tailwind: {Tailwind, :install_and_run, [:default, ~w(--watch)]}
  ]
```

¡Eso es todo! ¡Ahora hay que iniciar el servidor y observar cómo Tailwind se descarga e instala automáticamente!

```console
$ mix phx.server
[info] Running MyAppWeb.Endpoint with cowboy 2.9.0 at 127.0.0.1:4000 (http)
[debug] Downloading tailwind from https://github.com/tailwindlabs/tailwindcss/releases/download/v3.0.7/tailwindcss-macos-x64
[info] Access MyAppWeb.Endpoint at http://localhost:4000
Rebuilding...
Done in 482ms.
[debug] Live reload: priv/static/assets/app.css
```

Lo anterior solamente es cierto hasta la versión 3.0.* de tailwind y la primer versión de la biblioteca de phoenix tailwind.

## Para versiones más recientes

1. Crear el proyecto

Es probable que ya se tenga un proyecto creado, pero en caso de que sea nuevo es más simple, solo hay que seguir la [guía de instalación](https://hexdocs.pm/phoenix/installation.html), en resumen para este punto solo es:

```terminal
$ mix phx.new myproject
$ cd myproject
```

2. Instalar el plugin de Tailwind CCS

Se debe añadir el plugin a las dependencias en el archivo `mix.exs`:

```elixir
defp deps do
  [
    {:tailwind, "~> 0.1", runtime: Mix.env() == :dev}
  ]
end
```

**Nota:** Hay que recordar ejecutar `mix deps.get` después del cambio en el archivo para que se instale.

3. Configurar el plugin

Esto ya está explicado anteriormente, sin embargo para facilitar la ejecución se puede ver como sigue:

```elixir
config :tailwind, version: "3.1.6", default: [
  args: ~w(
    --config=tailwind.config.js
    --input=css/app.css
    --output=../priv/static/assets/app.css
  ),
  cd: Path.expand("../assets", __DIR__)
]
```

4. Actualizar el script para desarrollo

Esto se logra configurando un alias para construir el CSS en cada despliegue:

```elixir
defp aliases do
  [
    "assets.deploy": ["tailwind default --minify", "esbuild default --minify", "phx.digest"]
  ]
]
```

5. Habilitar observador (watcher) en desarrollo

Esto se hace agregando Tailwind a la lista de observadores en el archivo `./config/dev.exs`:

```elixir
watchers: [
  tailwind: {Tailwind, :install_and_run, [:default, ~w(--watch)]}
]
```

6. Instalar la dependencia

Se ejecuta el comando de instalación para descargar la CLI de Tailwind autónomo (standalone) y generar un archivo `tailwind.config.js` en el directorio `./assets`

```terminal
$ mix tailwind.install
```

7. Se configuran las plantillas

Hay que agregar las rutas de las plantillas en el archivo `./assets/tailwind.config.js`

```elixir
module.exports = {
  content: [
    './js/**/*.js',
    '../lib/*_web.ex',
    '../lib/*_web/**/*.*ex',
  ],
  theme: {
    extend: {},
  },
  plugins: [],
}
```

8. Añadir directivas de Tailwind al CSS

Las directivas `@tailwind` de las capas de `Tailwind` se deben añadir al archivo `./assets/css/app.css`

```css
# assets/css/app.css
@tailwind base;
@tailwind components;
@tailwind utilities;
```

9. Eliminar la importación por defecto de CSS

Hay que quitar el `import` del archivo `./assets/js/app.js`, ya que Tailwind ahora se encarga de esto.

```JavaScript
// assets/js/app.js  Se deben eliminar las siguientes líneas

- // Remove this line if you add your own CSS build pipeline (e.g postcss).
- import "../css/app.css"
```

9. Compilar el proyecto

Se ejecuta el proceso de compilación con `mix phx.server`

```terminal
$ mix phx.server
```

10. Tailwind en el proyecto

Ahora ya se pueden usar las clases de estilos de Tailwind para diseñar el contenido

```html
# index.html.heex
<h1 class="text-3xl font-bold underline">
  Hello world!
</h1>
```

### Recursos

* [Las guías de introducción a Tailwind](https://tailwindcss.com/docs/utility-first)
* [El sitio de Phoenix](https://www.phoenixframework.org/)
* [El instalador oficial de tailwind en hexdocs](https://hexdocs.pm/tailwind/Tailwind.html)




## Tailwind y Phoenix

Tailwind v3 se [se lanzó en diciembre del año pasado](https://tailwindcss.com/blog/tailwindcss-v3) con algunas ...


## ¿Que es mix test.watch?

Es una tarea para ejecutar pruebas cada vez que cambian los archivos de origen. Para tener acceso a esta tarea se debe hacer lo siguiente:

Instalar [la dependencia](https://github.com/lpil/mix-test.watch) con `mix`:

```elixir
# En el archivo mix.exs
 defp deps do
    [
    {:mix_test_watch, "~> 1.0", only: :dev, runtime: false},
    ..
    ]
  end
```
y ejecutamos `mix deps.get`:
```bash
$ mix deps.get
Resolving Hex dependencies...
Dependency resolution completed:
Unchanged:
  ..
  mix_test_watch 1.0.2
  ...
All dependencies are up to date
```
Ahora podemos ejecutar la instrucción `mix test.watch`:
```bash
$ mix test.watch

Running tests...
..............

Finished in 0.2 seconds
14 tests, 0 failures

Randomized with seed 285645
```
Con lo anterior el cursor permanecerá parpadeando y en espera de que cambie algún archivo para que se ejecuten nuevamente las pruebas. 
Aquí la ventaja es que en cuestión de milesimas de segundos tendrás el resultado de la prueba y sabrás que está fallando.
```elixir
..

  1) test messages list_messages/0 returns all messages (Contact.APITest)
     test/contact/api_test.exs:26
     Assertion with == failed
     code:  assert API.list_messages() == contact
     left:  [%API.Contact{__meta__: #Ecto.Schema.Metadata<:loaded, "messages">, email: "some email", id: 200, inserted_at: ~N[2020-12-09 00:16:28], message: "some message", name: "some name", updated_at: ~N[2020-12-09 00:16:28]}]
     right: %API.Contact{__meta__: #Ecto.Schema.Metadata<:loaded, "messages">, email: "some email", id: 200, inserted_at: ~N[2020-12-09 00:16:28], message: "some message", name: "some name", updated_at: ~N[2020-12-09 00:16:28]}
     stacktrace:
       test/contact/api_test.exs:28: (test)

...........

Finished in 0.7 seconds
14 tests, 1 failure

Randomized with seed 240462
```

### Opciones interesantes

* `--seed`
 Ejecutar la prueba de manera aleatoria puede ser de ayuda, sin embargo cuando una prueba falla lo mejor es usar la opción `--seed 0` de esta manera se ejecutaran las pruebas en la misma secuencia que la prueba anterior. En caso de que conozcas el seed puedes usarlo con esta opción, el `seed` del ejemplo anterior es `240462`.

* `--max-failures`
Posiblemente quieras probar varios escenarios al mismo tiempo, sin embargo lo mejor es detenerse en la prueba a la primer falla. Para esto `--max-failures 1` es tu amigo.

* `--stale`
Ejecuta las pruebas que hacen referencia a módulos que cambiaron desde la última vez que se ejecutaron las pruebas con `--stale`. 

En general hay más opciones que se pueden consultar con `mix help test`.

## Ahora las notificaciones

Existe un proyecto que permite concentrarnos en el código y nos hace saber cuando fallan las pruebas. Se llama [`ex_unit_notifier`](https://github.com/navinpeiris/ex_unit_notifier).

> **NOTA:** Para que funcione apropiadamente se requiere lo siguiente:
> * En Mac OS
> [Terminal Notifier](https://github.com/julienXX/terminal-notifier)
> * En Linux
> [notify-send](http://manpages.ubuntu.com/manpages/xenial/man1/notify-send.1.html)

Empezamos instalando la dependencia:

```elixir
# En mix.exs
def deps do
  [{:ex_unit_notifier, "~> 0.1", only: :test}]
end
```

Se actualizan las dependencias:

```bash
$ mix deps.get
```

Y por último se agrega `ExUnitNotifier` a la configuración de `ExUnit` en el archivo `test/test_helper.exs`.

```elixir
ExUnit.configure formatters: [ExUnit.CLIFormatter, ExUnitNotifier]
ExUnit.start()
```

Ahora si ejecutamos las pruebas:

```bash
mix test.watch --stale --max-failures 1 --trace --seed 0
```

Podremos ver las notificaciones cuando falla:

![Test failed](/images/2020-12-08--test-watch-elixir/test_failed.png)

o cuando pasa:

![Test success](/images/2020-12-08--test-watch-elixir/test_success.png)

### Referencias:

* [Mix test.watch](https://github.com/lpil/mix-test.watch)
* [ex_unit_notifier](https://github.com/navinpeiris/ex_unit_notifier)
* [Terminal Notifier](https://github.com/julienXX/terminal-notifier)
* [notify-send](http://manpages.ubuntu.com/manpages/xenial/man1/notify-send.1.html)

### Bibliografía recomendada

![Testing Elixir](/images/2020-12-08--test-watch-elixir/testing_book.jpg)

* <a target="_blank" href="https://www.amazon.com.mx/gp/product/1680507826/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1680507826&linkCode=as2&tag=iverblog-20&linkId=e7c00d6891d734fe1c563eab0076742c">Testing Elixir: Effective and Robust Testing for Elixir and Its Ecosystem</a><img src="//ir-mx.amazon-adsystem.com/e/ir?t=iverblog-20&l=am2&o=34&a=1680507826" width="1" height="1" border="0" alt="" style="border:none !important; margin:0px !important;" />




## ¿Que es mix test.watch?

Es una tarea para ejecutar pruebas cada vez que cambian los ...


Cuando se empieza a trabajar con un lenguaje de programación, se suele buscar un editor que nos facilite la vida. En Elixir una de las configuraciones más comunes es usar [Spacemacs][spacemacs] y [Alchemist][alchemist]. A continuación describo los pasos que he seguido para instalar ambos usando la guía que se ha publicado en el [foro de elixir][elixir-forum].

- [Instalación](#install)
  * [1. Instalando Emacs](#install-emacs)
  * [2. Instalando Spacemacs](#install-spacemacs)
  * [3. Agregar la capa de Elixir](#elixir-layer)
  * [4. Instalar Ack ó Ag](#install-ack-ag)
  * [5. [Opcional]](#optional)
  * [6. Para usuarios de Mac](#mac-users)
- [Documentación](#docs)
- [Más Referencias](#refs)

<a name="install"></a>

## Instalación

Lo primero es instalar Emacs, después Spacemacs y por último la capa de Elixir.

<a name="install-emacs"></a>

### 1. Instalando Emacs

Aquí están las instrucciones para OS X (de su [wiki][wiki-emacs]). Para otras plataformas se puede consultar [la página del proyecto][gnu-project]. Instalación habitual de Emacs:

```terminal
$ brew update
$ brew install emacs --with-cocoa
$ brew linkapps emacs
```

O bien, la instalación recomendada de SpaceMacs:

```terminal
$ brew tap d12frosted/emacs-plus
$ brew install emacs-plus
$ brew linkapps emacs-plus
```

<a name="install-spaceemacs"></a>

### 2. Instalando Spacemacs

Si previamente has usado emacs lo mejor es respaldar tu directorio `~/.emacs.d`

```terminal
$ mv ~/.emacs.d ~/.emacs.backup
$ git clone https://github.com/syl20bnr/spacemacs ~/.emacs.d
```

Ahora se puede iniciar Emacs y dejar que se instale todo. Después hay que reiniciar y la configuración de [Spacemacs][spacemacs] se activará. **Hay que seleccionar el modo VIM cuando sea requerido.**

<a name="elixir-layer"></a>

### 3. Agregar la capa de Elixir

En el archivo `~ / .spacemacs`, y en `dotspacemacs-configuration-layers` se agrega `elixir`. Se debe ver más o menos así:

```lisp
dotspacemacs-configuration-layers
   '(
     ruby
     ;; ----------------------------------------------------------------
     ;; Example of useful layers you may want to use right away.
     ;; Uncomment some layer names and press <SPC f e R> (Vim style) or
     ;; <M-m f e R> (Emacs style) to install them.
     ;; ----------------------------------------------------------------
     helm
     ;; auto-completion
     ;; better-defaults
     emacs-lisp
     ;; git
     ;; markdown
     ;; org
     ;; (shell :variables
     ;;        shell-default-height 30
     ;;        shell-default-position 'bottom)
     ;; spell-checking
     ;; syntax-checking
     ;; version-control
     elixir
     )
```

Si se reinicia [SpaceMacs][spacemacs] se instalará todo. En lo personal prefiero recargar la configuración usando `SPC f e R`.

<a name="install-ack-ag"></a>

### 4. Instalar Ack ó Ag

Son herramientas recomendadas para aumentar la velocidad de búsqueda.

* [Ack][ack-url] es una herramienta como `grep`, optimizada para programadores. 
* [Ag][ag-url] es como Ack, pero afirma ser 5-10 veces más rápido.

<a name="optional"></a>

### 5. [Opcional]

Habilitar el desplazamiento suave ([smooth scrolling][smooth-scroll]), [NeoTree][neotree] a la derecha y restauración de sesión.

Para esto hay que agregar las últimas 5 líneas en la configuración de usuario (`defun dotspacemacs/user-config ()` que debe quedar como:

```lisp
(defun dotspacemacs/user-config ()
  "Configuration function for user code.
This function is called at the very end of Spacemacs initialization after
layers configuration.
This is the place where most of your configurations should be done. Unless it is
explicitly specified that a variable should be set before a package is loaded,
you should place your code here."
  ;; scroll one line at a time (less "jumpy" than defaults)
  (setq mouse-wheel-scroll-amount '(1 ((shift) . 1))) ;; one line at a time
  (setq mouse-wheel-progressive-speed nil) ;; don't accelerate scrolling
  (setq mouse-wheel-follow-mouse 't) ;; scroll window under mouse
  (setq scroll-step 1) ;; keyboard scroll one line at a time
  )
```

#### NeoTree en el lado derecho

Para que NeoTree `SPC f t` se abra en el lado derecho se agrega:
`'(neo-window-position (quote right))` en las variables (`custom-set-variables`) dentro del archivo `.spacemacs` (luego se reinicia o bien, se recarga la configuración). 

#### Restaurar sesión

Se asigna `dotspacemacs-auto-resume-layouts` a `t` en el archivo `.spacemacs`; esto restaurará la sesión cuando se abra SpaceMacs.

<a name="mac-users"></a>

### 6. Para usuarios de Mac

#### Agregando una fuente

La fuente predeterminada no parece ser una incluida con OS X, en el archivo .spacemacs (desde SpaceMacs `SPC f e d`) y en `dotspacemacs-default-font` cambiar la fuente a `"Menlo"` y el tamaño a `12`.

#### El shell en Emacs

Para que Emacs respete el archivo `~/.bash_profile` se debe instalar `exec-path-from-shell`. Se puede usar `SPC SPC package-install` y después ingresar `exec-path-from-shell`.

Después se abre o crea el archivo `.bashrc` y al final se debe escribir `. ~/.bash_profile`.

<a name="docs"></a>

## Documentación

### Donde empezar con Spacemacs

* [Este documento][vim-spacemacs] está orientado a cerrar la brecha entre vim y Spacemacs.
* [La Documentación de SpaceMacs][spacemacs-doc]

### Instalando paquetes

Los paquetes se installan con [Melpa][melpa], el Administrador de paquetes de Emacs. Se puede verificar si un paquete ya está instalado con `SPC h SPC` seguido del nombre del paquete.

* Si se desea agregar una capa (`layer`), se debe agregar a la lista de `layers` en el archivo `.spacemacs` y reiniciar.
* Si es un paquete se puede instalar con `SPC SPC <package name> RET`

La mayoría de los paquetes están en Melpa e incluidos por SpaceMacs, pero si no, se puede agregar el nombre del paquete a `dotspacemacs-optional-packages` y reiniciar.

### Consejos rápidos con Spacemacs

#### Abrir y recargar configuración

* Abrir el archivo `.spacemacs` desde SpaceMacs con `SPC f e d`
* Después de hacer cambios en el archivo `.spacemacs`, se puede usar `SPC f e R` para recargar la configuración.
* En ocasiones basta con recargar la configuración pero a veces se necesita reiniciar la aplicación con `SPC q r`

#### Búsqueda, visualización de documentos y misceláneos

* `SPC h SPC` para abrir la documentación
* Para buscar información de una función de Emacs `SPC h d f <function-name> RETORNO`, por ejemplo, `SPC h d f what-cursor-position RETURN`
* Cuando en algún lado se lee algo como `M-x <comando>`, quiere decir que se debe presionar `SPC SPC` y luego escribir <comando>.
* `,` es la tecla líder, cuando se hace referencia a `SPC m <algo>` se puede usar `, <algo>`.

#### Búsqueda

* `SPC p p` - Muestra proyectos abierto previamente
* `SPC p f` - Buscar archivo en el proyecto
* `SPC s s` - Búsqueda en picada `Swoop search` (búsqueda en archivo) habitualmente en vim `/`
* `SPC f f` - Buscar archivo, búsqueda difusa (),
* `SPC f r` - Encuentra/muestra archivos recientes
* `SPC /` - Buscar patrón (texto) en un archivo abierto (atajo de `SPC s p`)
* `SPC *` - Igual que `SPC /` pero busca lo que está debajo del cursor. Si necesita buscar un término exacto, por ejemplo escapar espacios: `SPC / see \ the \ posts`
* `SPC s a p` buscar patrón (texto) en el proyecto

#### Ventanas

* `SPC w s` divide la ventana `SPC w v` la divide verticalmente
* `SPC w d` eliminar/cerrar ventana (o `Command W` en OS X)

#### Buffers

* `SPC b b` lista los buffers
* `SPC TAB` va al último buffer

#### NeoTree

* `SPC f t` abre NeoTree
* `SPC 0` selecciona la ventana de NeoTree
* `SPC 1` selecciona la ventana (1)

#### Shell

* `SPC '` abre la terminal (en el directorio donde se encuentra el archivo actual)
* `SPC p '` abre la terminal en la raíz del proyecto

#### Comentar / Descomentar

* `g c c` or `SPC c l` comenta/descomenta una línea
* `g c 3 j` comenta 3 líneas para abajo
* `g c 3 k` comenta 3 líneas para arriba
* `v` selecciona el código (y después `g c`)


<a name="refs"></a>

## Más Referencias

### Tutoriales de Spacemacs

* [Spacemacs ABC (YouTube)][spacemacs-abc] - by Eivind Fonn
* [Development Workflow with Spacemacs (YouTube)][workflow] - by Jon Canada (Elixir user)

### Publicaciones en blogs

* [Spacemacs and Alchemist to make Elixir of immortality][space-alchemist] by Zohaib
* [An Absolute Beginners Guide to Spacemacs for Academic Writing][beginner-guide]
* [SpaceMAcs tips][tips] by Bebbu - Algunos consejos para comenzar

### Temas de Spacemacs

* [Elixify theme][elixify] (ver también el [hilo][] de Elixify en el foro).
* [Code School][code-school] portado desde TextMate

### SpaceMacs Gitter Chat

* [https://gitter.im/syl20bnr/spacemacs][gitter]: son muy activos y serviciales en el canal, si se necesita ayuda es una excelente opción.

### Solucionando de problemas

* Si existe algún aviso (`warning`) al inicio, con `SPC b b` se listan los buffers y después con `Messages`.

### Alchemist Elixir

* [Alchemist uso básico][alchemist-basic]

### Alchemist docs

* [Alchemist documentación oficial][alchemist-doc] (para emacs)


[spacemacs]: http://spacemacs.org/
[alchemist]: http://www.alchemist-elixir.org/
[elixir-forum]: https://elixirforum.com/t/spacemacs-general-discussion-blog-posts-wiki/109
[wiki-emacs]: http://wikemacs.org/wiki/Installing_Emacs_on_OS_X
[gnu-project]: https://www.gnu.org/software/emacs/download.html
[ack-url]: http://beyondgrep.com/
[ag-url]: https://github.com/ggreer/the_silver_searcher
[smooth-scroll]: https://www.emacswiki.org/emacs/SmoothScrolling
[neotree]: https://github.com/jaypei/emacs-neotree
[vim-spacemacs]: http://spacemacs.org/doc/VIMUSERS.html
[spacemacs-doc]: https://github.com/syl20bnr/spacemacs/blob/master/doc/DOCUMENTATION.org
[melpa]: http://melpa.milkbox.net/
[spacemacs-abc]: https://www.youtube.com/watch?v=ZFV5EqpZ6_s&list=PLrJ2YN5y27KLhd3yNs2dR8_inqtEiEweE
[workflow]: https://www.youtube.com/watch?v=k5X2Hb3tc2s
[space-alchemist]: http://www.zohaib.me/spacemacs-and-alchemist-to-make-elixir-of-immortality/
[beginner-guide]: https://ontologicalblog.com/2016/10/14/an-absolute-beginners-guide-to-spacemacs-for-academic-writing/
[tips]: https://beppu.github.io/post/spacemacs-tips/
[elixify]: https://github.com/AstonJ/editor-themes/tree/master/Elixify/Spacemacs
[hilo]: https://elixirforum.com/t/introducing-elixify-a-code-editor-theme-for-elixir/450
[code-school]: https://github.com/AstonJ/editor-themes/tree/master/CodeSchool/Spacemacs
[gitter]: https://gitter.im/syl20bnr/spacemacs
[alchemist-basic]: http://alchemist.readthedocs.io/en/latest/basic_usage/
[alchemist-doc]: http://alchemist.readthedocs.org/en/latest/


Cuando se empieza a trabajar con un lenguaje de programación, se suele buscar un editor ...


Contenido de este artículo

- [El archivo YAML](#el-archivo-yaml)
- [Los pasos (Steps)](#los-pasos-steps)
  - [Las imágenes (Images)](#las-imágenes-images)
    - [Obteniendo las imágenes](#obteniendo-las-imágenes)
  - [Los comandos (Commands)](#los-comandos-commands)
  - [Las variables de entorno (Environment)](#las-variables-de-entorno-environment)
  - [Los complementos (Plugins)](#los-complementos-plugins)
  - [Las condiciones (Conditions)](#las-condiciones-conditions)
    - [When](#when)
    - [Failure](#failure)
    - [Detach](#detach)
    - [Privileged Mode](#privileged-mode)
- [Referencias](#referencias)

Al igual que muchas otras herramientas de integración continua, [Drone](/drone-ci/) busca un archivo de configuración por defecto llamado `.drone.yml` en su repositorio para determinar cómo debe manejar el código.

En las versiones más recientes `>= 1.6.5` se puede configurar el nombre del archivo en la sección de `settings`.

![iver.mx](/images/2020-07-14--drone-yaml-file/settings_drone.jpg)

<a name="yaml-file"></a>

## El archivo YAML

El archivo YAML define una tubería. Una tubería (`pipeline`) es un proceso de integración continua que ejecuta múltiples pasos, uno tras otro. Un archivo de configuración común puede ser el siguiente:

```yaml
kind: pipeline
name: default

services:
- name: redis
  image: redis:latest
  ports:
  - 6379

steps:
- name: backend
  image: golang:1.11
  commands:
  - go build
  - go test -v

- name: frontend
  image: node
  commands:
    - npm install
    - npm run test
    - npm run lint

```

En el ejemplo se puede observar que el tipo de configuración es una tubería (`pipeline`) y que es la que por defecto se ejecuta. El nombre identifica la ejecución de la tubería, por lo que a veces es útil poner algo como:

```yaml
kind: pipeline
name: golang-1.11
..
...
kind: pipeline
name: golang-1.14
```

En la siguiente sección del archivo se define una imagen de redis que se empleara como un servicio en el proceso de ejecución de todos los pasos (estará disponible hasta que se termine el último paso) y se publica en el puerto `6379`.

```yaml
services:
- name: redis
  image: redis:latest
  ports:
  - 6379
```

Por último se encuentra la definición de los pasos a ejecutar, de manera regular se ejecutan en secuencia. Opcionalmente, se puede usar la clave `depends_on` para describir los pasos de compilación como un [gráfico acíclico dirigido][acyclic-graph].

```yaml
kind: pipeline
name: default

steps:
- name: backend
  image: golang
  commands:
  - go build
  - go test

- name: frontend
  image: node
  commands:
  - npm install
  - npm test

- name: notify
  image: plugins/slack
  settings:
    webhook:
      from_secret: webhook
  depends_on:
  - backend
  - frontend
```

<a name="steps"></a>

## Los pasos (Steps)

Los pasos de la tubería se definen como una serie de comandos de shell.

<a name="images"></a>

### Las imágenes (Images)

Los pasos de la tubería se definen como una serie de contenedores Docker. Por lo tanto, cada paso debe definir la imagen de Docker utilizada para crear el contenedor.

```yaml
kind: pipeline
type: docker
name: default

steps:
- name: build
  image: golang:1.12
  commands:
  - go build
  - go test
```

Drone admite cualquier imagen Docker válida de cualquier registro Docker:

```yaml
image: golang
image: golang:1.7
image: library/golang:1.7
image: index.docker.io/library/golang
image: index.docker.io/library/golang:1.7
image: docker.company.com/golang
```

#### Obteniendo las imágenes

Si la imagen no existe en el caché local, Drone le indica a Docker que extraiga la imagen automáticamente. 

Nunca se necesitará extraer imágenes manualmente. Si la imagen está etiquetada con: último, ya sea explícita o implícitamente, Drone intenta extraer la versión más reciente de la imagen del registro remoto, incluso si la imagen existe en el caché local. 

Para extraer solo la imagen si no se encuentra en el caché local:

```yaml
steps:
- name: build
  pull: if-not-exists
  image: golang
```

Las opciones de `pull` disponibles son:

- **if-not-exists** Si no se encuentra en el caché local
- **always** Siempre obtener la versión más reciente
- **never** Siempre usar la versión del caché local

<a name="commands"></a>

### Los comandos (Commands)

Los comandos se ejecutan dentro del directorio raíz del repositorio git. La raíz del repositorio git, también llamado espacio de trabajo (`workspace`), es compartida por todos los pasos en la tubería. Esto permite que los artefactos persistan entre los pasos.

En el ejemplo anterior, el paso de backend se convierte en el siguiente script:

```bash
#!/bin/sh
set -e
set -x

go build
go test
```

El script de shell anterior se ejecuta como el punto de entrada (`entrypoint`) de docker. El siguiente comando docker es un ejemplo (incompleto) de cómo se ejecuta el script:

```terminal
$ docker run --entrypoint=build.sh golang
```

El código de salida del contenedor se usa para determinar si el paso está pasando o no. Si un comando devuelve un código de salida distinto de cero, el paso se marca como erróneo.

<a name="envs"></a>

### Las variables de entorno (Environment)

La sección de entorno proporciona la capacidad de definir variables de entorno en el ámbito de los pasos de tuberías de manera individual.

```yaml
steps:
- name: backend
  image: golang
  environment:
    GOOS: linux
    GOARCH: amd64
  commands:
  - go build
  - go test
```

<a name="plugins"></a>

### Los complementos (Plugins)

Los `plugins` son contenedores acoplables que encapsulan comandos y se pueden compartir y reutilizar en las tuberías (`pipelines`). Los ejemplos de complementos incluyen el envío de notificaciones de Slack, la creación y publicación de imágenes de Docker y la carga de artefactos en S3. Existe un repositorio de los [complementos disponibles para drone][plugins].

```yaml
- name: notify
  image: plugins/slack
  environment:
    SLACK_WEBHOOK:
      from_secret: slack_webhook_url
  settings:
    channel: git
    link_names: true
  when:
      status:
        - success
        - failure
```

<a name="conds"></a>

### Las condiciones (Conditions)

#### When

La sección `when` proporciona la capacidad de limitar condicionalmente la ejecución de pasos en tiempo de ejecución. El siguiente ejemplo limita la ejecución de pasos por rama, sin embargo, puede limitar la ejecución por evento, referencia, estado y más.

```yaml
steps:
- name: backend
  image: golang
  commands:
  - go build
  - go test
  when:
    branch:
    - master
```

Se puede usar la condición de estado para anular el comportamiento predeterminado del tiempo de ejecución y ejecutar pasos incluso cuando el estado de la tubería sea un error:

```yaml
- name: notify
  image: plugins/slack
  settings:
    webhook: https://hooks.slack.com/services/...
  when:
    status:
    - failure
    - success
```

#### Failure

El atributo de falla permite personalizar cómo el sistema maneja la falla de un paso individual. Esto puede ser útil si se desea permitir que un paso falle sin fallar la tubería en general.

```yaml
steps:
- name: backend
  image: golang
  failure: ignore
  commands:
  - go build
  - go test
```

#### Detach

El atributo detach permite ejecutar el paso de la tubería en segundo plano. La ejecución comienza el paso, se separa (`detach`) y se ejecuta en segundo plano, e inmediatamente pasa al siguiente paso. El caso de uso de destino para esta función es iniciar un servicio o demonio, y luego ejecutar pruebas unitarias contra el servicio en pasos posteriores.

> Se debe tener en cuenta que un paso separado no puede fallar la tubería. La ejecución puede ignorar el código de salida.

#### Privileged Mode

El atributo `privileged` ejecuta el contenedor con privilegios escalados. Esto es equivalente a ejecutar un contenedor con el indicador `--privileged`.

```yaml
steps:
- name: backend
  image: golang
  privileged: true
  commands:
  - go build
  - go test
  - go run main.go -http=:3000
```
> Esta opción solo está disponible para repositorios de confianza. El modo privilegiado efectivamente otorga acceso de `root` al contenedor la máquina host.

<a name="refs"></a>

## Referencias

Todo lo anterior se puede encontrar en la documentación de drone (en inglés):

- [Configuración de las tuberías][pipelines]
- [Definir servicios en drone][drone-services]
- [Configurar tuberías en paralelo][parallel-pipelines]
- [Sintaxís de los pasos][steps]
- [Imágenes de docker][images]

[acyclic-graph]: https://en.wikipedia.org/wiki/Directed_acyclic_graph
[pipelines]: https://docs.drone.io/quickstart/kubernetes/#configure-your-pipeline
[drone-services]: https://docs.drone.io/pipeline/docker/syntax/services/
[parallel-pipelines]: https://discourse.drone.io/t/how-to-setup-parallel-pipeline-steps-1-0/3251
[steps]: https://docs.drone.io/pipeline/docker/syntax/steps/
[plugins]: http://plugins.drone.io/
[images]: https://docs.drone.io/pipeline/docker/syntax/images/


Contenido de este artículo

- [El archivo YAML](#el-archivo-yaml)
- [Los pasos (Steps)](#los-pasos-steps)
  - [Las imágenes (Images)](#las-imágenes-images)
 ...


## ¿Que es Drone?

Drone es un sistema de [integración](https://martinfowler.com/articles/continuousIntegration.html) y [entrega continua](https://martinfowler.com/bliki/ContinuousDelivery.html) basado en tecnología de contenedores. Utiliza un simple archivo de configuración [YAML](https://yaml.org/), un superconjunto de [docker-compose](https://docs.docker.com/compose/), para definir y ejecutar tuberías dentro de contenedores [Docker](https://www.docker.com/).

Tal como se puede ver en el [README.md en github](https://github.com/drone/drone), la sintaxis es simple y está hecho en [golang](https://golang.org/) 1.11. La primer versión con etiqueta (v0.2.0) fue liberada en [marzo del 2014](https://github.com/drone/drone/releases/tag/v0.2.0), lo cual nos habla sobre la estabilidad del software.

La característica más destacada de [Drone](https://drone.io/) es que utiliza contenedores para todo. Cada etapa en las tuberías (_pipelines_) más complejas en Drone se realiza a través de un contenedor Docker. Drone CI debe integrarse con un repositorio [Git](https://git-scm.com/) para obtener el código fuente del proyecto a liberar. Tiene una serie de complementos que se pueden implementar como contenedores Docker. Se pueden usar de la misma manera que se usan las herramientas UNIX (`ls`, `cat`, `tee`, etc.).

## ¿Para qué sirve?

Si se tiene experiencia en el desarrollo es posible que con lo descrito anteriormente se pueda inferir todo lo que se puede hacer y las ventajas que se tienen al usar los contenedores. Las siguientes son algunas consecuencias de usar los contenedores:

#### Configuración simple

Se evita perder el tiempo configurando servidores para compilar (una vieja práctica que ya no se usa mucho). Se puede elegir la [imagen de Docker](https://hub.docker.com/) al gusto y Drone aprovisionará automáticamente el entorno.

#### Construcciones aisladas 

Cada compilación se ejecuta en un contenedor Docker aislado, lo que le brinda control total. Se puede usar alguna configuración particular sin importar que sistema operativo se use. Se puede tomar como base alguna imagen construida previamente y añadir las herramientas necesarias en cada compilación o bien hacer una imagen en docker con todas las herramientas.

#### Diversidad

Existen infinidad de complementos (_plugins_) que se pueden usar con drone. No importa que tan complejo sea el proceso de construcción de un proyecto, se puede realizar un flujo que valide el desarrollo realizado.

## Ejemplo:

Un ejemplo simple.

```yaml
kind: pipeline
name: default

steps:
- name: backend
  image: golang:1.11
  commands:
  - go build
  - go test -v

- name: frontend
  image: node
  commands:
    - npm install
    - npm run test
    - npm run lint

services:
- name: redis
  image: redis:latest
  ports:
  - 6379
```

Un ejemplo más completo

```yaml
kind: pipeline
name: build

steps:
- name: backend
  image: golang:1.11
  commands:
  - go build
  - go test -v

- name: frontend
  image: node
  commands:
    - npm install
    - npm run test
    - npm run lint

services:
- name: redis
  image: redis:latest
  ports:
  - 6379
  volumes:
  - name: foo
    path: /bar

volumes:
- name: foo
  temp: {}

---
kind: pipeline
name: notify

steps:
- name: notify
  image: plugins/slack
  settings:
    room: general
    token:
      from_secret: token

node:
  disk: ssd

depends_on:
- build
```

¿Te gustaría saber más sobre integración continua? Te recomiendo el siguiente libro:

* <a target="_blank" href="https://www.amazon.com.mx/gp/product/B0026772IS/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B0026772IS&linkCode=as2&tag=iverblog-20&linkId=1117bc15b7b94ae96a91e83780706452">Continuous Integration: Improving Software Quality and Reducing Risk (Addison-Wesley Signature Series (Fowler)) (English Edition)</a><img src="//ir-mx.amazon-adsystem.com/e/ir?t=iverblog-20&l=am2&o=34&a=B0026772IS" width="1" height="1" border="0" alt="" style="border:none !important; margin:0px !important;" />



## ¿Que es Drone?

Drone es un sistema de [integración](https://martinfowler.com/articles/continuousIntegration.html) y [entrega continua](https://martinfowler.com/bliki/ContinuousDelivery.html) basado en tecnología ...


Uno de los principales cambios de paradigma en los desarrolladores que
empiezan a utilizar Elixir es el uso de Ecto como si fuera un [ORM](https://en.wikipedia.org/wiki/Object-relational_mapping). 

Justo este tema se trata en la publicación de [plataformatec](https://plataformatec.com) (realizada por José Valim) llamada [The Little Ecto Cookbook](https://pages.plataformatec.com.br/the-little-ecto-cookbook). 

A continuación haré un extracto en español de la publicación de "[What is new in Ecto 2.0](http://blog.plataformatec.com.br/wp-content/uploads/2016/11/whats-new-in-ecto-2-0.pdf)".

Los proyectos que utilizan Ecto pueden terminar con **God Schemas** (Esquemas Dios) que hacen de todo en el sistema. Comúnmente conocidos como **Modelos de Dios**, **Modelos gordos**. Dichos esquemas pueden contener cientos de campos, que a menudo reflejan malas decisiones tomadas en la capa de datos. En lugar de proporcionar un solo esquema con campos que abarcan múltiples preocupaciones, es mejor dividir el esquema en múltiples contextos.

> "Elixir no es un lenguaje Orientado a Objetos, por lo tanto Ecto no puede ser un ORM (Object-Relational Mapper)."

## O es para Objetos

Los objetos combinan estado y comportamiento juntos. En el mismo objeto de `user`, puede tener datos como `user.name` y el comportamiento, como confirmar una cuenta de uso particular a través de `user.confirm()`.

Mientras que algunos lenguajes imponen diferentes sintaxis entre los datos de acceso (`user.name` sin paréntesis) y el comportamiento (`user.confirm()` con paréntesis), otros idiomas siguen el Principio de Acceso Uniforme ([Uniform Access Principle](https://en.wikipedia.org/wiki/Uniform_access_principle)) en el que un objeto no debe hacer una distinción entre las dos sintaxis. Eiffel y Ruby son idiomas que siguen tal principio.

En Elixir, trabajamos con diferentes estructuras de datos como tuplas, listas, mapas y otros. El comportamiento no se puede adjuntar a las estructuras de datos. El comportamiento siempre se agrega a los módulos a través de funciones.

> Elixir falla la prueba de "acoplamiento de estado y comportamiento".

Cuando es necesario trabajar con datos estructurados, Elixir proporciona estructuras (`structs`). Las estructuras definen un conjunto de campos. Una estructura será referenciada por el nombre del módulo donde se define:

```elixir
defmodule User do
  defstruct [:name, :email]
end

user = %User{name:"John Doe", email:"john@example.com"}
```

Una vez que se crea una estructura de usuario, podemos acceder a su correo electrónico a través de `user.email`. Sin embargo, las estructuras son solo datos. Es imposible invocar `user.confirm()` en una estructura en particular de una manera que ejecute el código relacionado con la confirmación por correo electrónico.

Aunque no podemos adjuntar el comportamiento a las estructuras, es posible agregar funciones al mismo módulo que define la estructura:


```elixir
defmodule User do
  defstruct [:name, :email]
  
  def confirm(user) do
  	# Confirm the user email
  end
end
```

Incluso con la definición anterior, es imposible en Elixir confirmar un usuario dado llamando a `user.confirm()`. En su lugar, se requiere el prefijo de usuario y la estructura de usuario se debe dar explícitamente como argumento, como en `User.confirm(user)`. Al final del día, no hay acoplamiento estructural entre la estructura de `user` y las funciones en el módulo `User`. Por lo tanto, Elixir no tiene _métodos_, tiene _funciones_. 

Sin tener objetos, Ecto ciertamente no puede ser un ORM. Sin embargo, si dejamos ir la letra "O" por un segundo, ¿puede Ecto seguir siendo un mapeador relacional?




Uno de los principales cambios de paradigma en los desarrolladores que
empiezan a utilizar Elixir es ...


**Aviso**: No todos los comandos funcionan en todas las distribuciones.

## Sistema Operativo

Tipo de distribución y versión:

```console
$ cat /etc/issue
$ cat /etc/*-release
$ cat /etc/lsb-release      # Debian based
$ cat /etc/redhat-release   # Redhat based
```

Versión del kernel y si es de 64 bits.

```console
$ cat /proc/version
$ uname -a
$ uname -mrs
$ rpm -q kernel
$ dmesg | grep Linux
$ ls /boot | grep vmlinuz-
```

Para ver que hay en las variables de entorno:

```console
$ cat /etc/profile
$ cat /etc/bashrc
$ cat ~/.bash_profile
$ cat ~/.bashrc
$ cat ~/.bash_logout
$ env
$ set
```

Alguna impresora:

```console
$ lpstat -a
```

## Servicios y Aplicaciones

Servicios que están corriendo. Servicios y sus privilegios de usuario:

```console
$ ps aux
$ ps -ef
$ top
$ cat /etc/services
```

Que servicios están corriendo como **root**:

```console
$ ps aux | grep root
$ ps -ef | grep root
```

Que aplicaciones están instaladas, que versiones tienen y cuales se están ejecutando.

```console
$ ls -alh /usr/bin/
$ ls -alh /sbin/
$ dpkg -l
$ rpm -qa
$ ls -alh /var/cache/apt/archivesO
$ ls -alh /var/cache/yum/
```

Para revisar la configuración de los servicios:

```console
$ cat /etc/syslog.conf
$ cat /etc/chttp.conf
$ cat /etc/lighttpd.conf
$ cat /etc/cups/cupsd.conf
$ cat /etc/inetd.conf
$ cat /etc/apache2/apache2.conf
$ cat /etc/my.conf
$ cat /etc/httpd/conf/httpd.conf
$ cat /opt/lampp/etc/httpd.conf
$ ls -aRl /etc/ | awk '$1 ~ /^.*r.*/
```

Hay algún *job* con ejecución programada:

```console
$ crontab -l
$ ls -alh /var/spool/cron
$ ls -al /etc/ | grep cron
$ ls -al /etc/cron*
$ cat /etc/cron*
$ cat /etc/at.allow
$ cat /etc/at.deny
$ cat /etc/cron.allow
$ cat /etc/cron.deny
$ cat /etc/crontab
$ cat /etc/anacrontab
$ cat /var/spool/cron/crontabs/root
```

Algún usuario y/o contraseña en texto plano:

```console
grep -i user [filename]
grep -i pass [filename]
grep -C 5 "password" [filename]
find . -name "*.php" -print0 | xargs -0 grep -i -n "var $password"   # archivos php
```

## Redes y comunicaciones

Redes e interfaces:

```console
$ /sbin/ifconfig -a
$ cat /etc/network/interfaces
$ cat /etc/sysconfig/network
```

Conocer la configuración de red:

```console
$ cat /etc/resolv.conf
$ cat /etc/sysconfig/network
$ cat /etc/networks
$ iptables -L
$ hostname
$ dnsdomainname
```

Que usuarios o host se comunican con el sistema:

```console
$ lsof -i
$ lsof -i :80
$ grep 80 /etc/services
$ netstat -antup
$ netstat -antpx
$ netstat -tulpn
$ chkconfig --list
$ chkconfig --list | grep 3:on
$ last
$ w
```

IP y dirección Mac 

```console
$ netstat -rn
$ arp -e
$ route
$ /sbin/route -nee
$ ifconfig en1 | awk '/ether/{print $2}'
```

Listar tráfico actual de red:

```console
# tcpdump tcp dst [ip] [port] and tcp dst [ip] [port]
$ tcpdump tcp dst 192.168.1.7 80 and tcp dst 10.5.5.252 21
```





**Aviso**: No todos los comandos funcionan en todas las distribuciones.

## Sistema Operativo

Tipo de distribución y ...


Si eres un usuario de Linux ya sabrás que existen varios tipos de líneas de comandos (conocidas habitualmente como _shells_)

* **Bourne Shell**: Creada por [Steven Bourne][1], fué incluida en la [versión 7 de UNIX][2] en 1979. Es conocida en el sistema como _sh_, varias funcionalidades y utilidades en la adminitración del sistema depeden de ella.
* **C shell**: Escrita por [Bill Joy][3], en la Universidad de California en Berkeley como parte de la versión de UNIX de Berkeley, BSD ([Berkeley Software Distribution][4]) un par de años después de la versión 7 de UNIX.
* **KornShell**: Desarrollada por [David Korn][5] en los [Laboratorios Bell][6] en 1980, basada en Bourne Shell e incluye varias características de C Shell. ksh siempre intenta respetar el Shell Language Standard (POSIX 1003.2 : “Shell and Utilities Language Committee”).
* **tcsh**: Basado en C shell, la **T** proviene de TENEX. Ken Greer es el autor que se inspiró en el sistema operativo TENEX por su capacidad de autocompletado de comandos. 
* **ZShell**: La primera versión de zsh fue escrita por Paul Falstad en 1990, cuando era estudiante en la Universidad de Princeton. El nombre zsh procede del profesor de Yale Zhong Shao, por entonces profesor asistente en la Universidad de Princeton.
* **Bash**: Su nombre es un acrónimo de Bourne-Again Shell. Interprete estándar para los sistemas GNU, oficialmente fue publicado el domingo 10 de enero de 1988. Brian Fox escribió la versión original de bash, Chet Ramey es ahora quién mantiene el proyecto.

[1]: https://en.wikipedia.org/wiki/Stephen_R._Bourne
[2]: https://en.wikipedia.org/wiki/Version_7_Unix
[3]: https://en.wikipedia.org/wiki/Bill_Joy
[4]: https://en.wikipedia.org/wiki/Berkeley_Software_Distribution
[5]: https://en.wikipedia.org/wiki/David_Korn_(computer_scientist)
[6]: https://en.wikipedia.org/wiki/Bell_Labs


<style>
.shadow-z-1 {
    -webkit-box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.12), 0 1px 2px 0 rgba(0, 0, 0, 0.24);
    -moz-box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.12), 0 1px 2px 0 rgba(0, 0, 0, 0.24);
    box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.12), 0 1px 2px 0 rgba(0, 0, 0, 0.24);
}
.table {
    width: 100%;
    max-width: 100%;
    margin-bottom: 2rem;
    background-color: #fff;
}
.table-bordered > thead > tr > th {
	border-bottom: 1px solid #e0e0e0;
	text-align: center;
}
.table-bordered > thead > tr > th, 
.table-bordered > thead > tr > td {
    border-bottom-width: 2px;
}
tbody > tr > td {
	border: 0;
	min-width: 150px;
    border-bottom: 1px solid #e0e0e0;
}
.table > thead > tr > th, .table > tbody > tr > th, .table > tfoot > tr > th, .table > thead > tr > td, .table > tbody > tr > td, .table > tfoot > tr > td {
    text-align: left;
    padding: 1rem;
    vertical-align: top;
    border-top: 0;
    -webkit-transition: all 0.3s ease;
    -o-transition: all 0.3s ease;
    transition: all 0.3s ease;
}
td, th {
    display: table-cell;
    vertical-align: inherit;
}
.table-hover.table-mc-light-blue > tbody > tr:hover > td, .table-hover.table-mc-light-blue > tbody > tr:hover > th {
    background-color: #b3e5fc;
}
</style>

Las siguientes combinaciones de teclas las he probado en **Bash** y en **tcsh**, si has empleado algún otro interprete de comandos por favor deja tu comentario para compartir el conocimiento.

<div class="shadow-z-1">
<table class="table table-hover table-mc-light-blue table-bordered">
<thead>
		<tr>
			<th>Atajo</th>
			<th>Descripción</th>
		</tr>
	</thead>
<tr><td width="100px"> Ctrl + A </td> <td>Ir al inicio de la línea en la que se está escribiendo</td></tr>
<tr><td> Ctrl + E </td><td> Ir al final de la línea en la que se está escribiendo</td></tr>
<tr><td> Ctrl + L </td><td> Limpia la pantalla, similiar al comando clear</td></tr>
<tr><td> Ctrl + U </td><td> Limpia la linea hasta antes de la posición del cursor </td></tr>
<tr><td> Ctrl + H </td><td> Lo mismo que la tecla de retroseso </td></tr>
<tr><td> Ctrl + R </td><td> Te permite buscar en los comandos ingresados previamente </td></tr>
<tr><td> Ctrl + C </td><td> Mata lo que sea que estés ejecutando </td></tr>
<tr><td> Ctrl + D </td><td> Sale del shell actual </td></tr>
<tr><td> Ctrl + Z </td><td> Pone lo que sea que estés ejecutando en un proceso suspendido al fondo. fg lo restaura.</td></tr>
<tr><td> Ctrl + W </td><td> Borra la plabra anterior al cursor </td></tr>
<tr><td> Ctrl + K </td><td> Limpia la línea después del cursor </td></tr>
<tr><td> Ctrl + T </td><td> Cambia los dos últimos caracteres que están antes del cursor </td></tr>
<tr><td> Esc + T	</td><td>	Cambia las dos palabras antes del cursor </td></tr>
</table>
</div>

Para saber un poco más sobre bash, te recomiendo los siguientes libros:

* <a target="_blank" href="https://www.amazon.com.mx/gp/product/0596009658/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596009658&linkCode=as2&tag=iverblog-20&linkId=fc789762a92f6557139a574bb4565a36">Learning the bash Shell</a><img src="//ir-mx.amazon-adsystem.com/e/ir?t=iverblog-20&l=am2&o=34&a=0596009658" width="1" height="1" border="0" alt="" style="border:none !important; margin:0px !important;" />
* <a target="_blank" href="https://www.amazon.com.mx/gp/product/B00JRGCFLA/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B00JRGCFLA&linkCode=as2&tag=iverblog-20&linkId=b80ad3c6bfd510742b79c49a93d5da67">Command Line Kung Fu: Bash Scripting Tricks, Linux Shell Programming Tips, and Bash One-liners (English Edition)</a><img src="//ir-mx.amazon-adsystem.com/e/ir?t=iverblog-20&l=am2&o=34&a=B00JRGCFLA" width="1" height="1" border="0" alt="" style="border:none !important; margin:0px !important;" />
* <a target="_blank" href="https://www.amazon.com.mx/gp/product/B015FZAXU6/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B015FZAXU6&linkCode=as2&tag=iverblog-20&linkId=c48df7cb906f5cb084347d5108203f86">Shell Scripting: How to Automate Command Line Tasks Using Bash Scripting and Shell Programming (English Edition)</a><img src="//ir-mx.amazon-adsystem.com/e/ir?t=iverblog-20&l=am2&o=34&a=B015FZAXU6" width="1" height="1" border="0" alt="" style="border:none !important; margin:0px !important;" />



Si eres un usuario de Linux ya sabrás que existen varios tipos de líneas de ...


Como resultado de haber reunido algunas baratijas de scripts para configurar el terminal, guardé algunos en mis archivos de configuración.

## Motivación

Debido a que hay muchos estilos para configurar cada entorno y estuve usando diversos sistemas operativos, encontré la mejor forma (para mi) copiando mi configuración de una computadora a otra usando los **dot files** de Mac y Linux.

## Instalación

Primero clonamos el repositorio:

```console
git clone https://github.com/iver/Baubles.git ~/Config
```

Ahora hay que darle permiso de ejecución al script de instalación y ejecutarlo:

```console
$> chmod +x install.sh
$> ./install.sh
```

También tienes la opción de desinstalarlo:

```console
$> chmod +x uninstall.sh
$> ./uninstall.sh
```

La configuración está lista!

## Repositorio

Si deseas descargar, copiar o abrir alguna incidencia. No dudes en visitar el repositorio de [github](https://github.com/iver/Baubles).

* [https://github.com/iver/Baubles]()



Como resultado de haber reunido algunas baratijas de scripts para configurar el terminal, guardé algunos ...

Iver's Blog

Probar AWS SQS localmente

Probar AWS SQS localmente

Tailwind y Phoenix

Tailwind y Phoenix

mix test.watch

¿Que es mix test.watch?

Spacemacs y Elixir

El yaml de drone

Drone CI

¿Que es Drone?

Ecto y Elixir

Diagnosticar el sistema operativo

Sistema Operativo

Tipos de línea de comandos y atajos

Vim y mis chucherias