Posts Goss: Una Guía Completa para Pruebas de Infraestructura en Linux y Docker
Post
Cancel

Goss: Una Guía Completa para Pruebas de Infraestructura en Linux y Docker

En el mundo de la administración de sistemas y la gestión de contenedores, la garantía de la integridad y el correcto funcionamiento de la infraestructura es esencial. Goss es una herramienta de prueba de infraestructura simple pero poderosa que permite verificar la integridad de sistemas Linux y contenedores Docker de manera automatizada. En este artículo, exploraremos qué es Goss, cómo instalarlo y utilizarlo para realizar pruebas simples en sistemas Linux, así como también cómo integrarlo en un Dockerfile para validar el funcionamiento de una aplicación, utilizando como ejemplo un contenedor de WordPress.

¿Qué es Goss?:

Goss es una herramienta de prueba de infraestructura escrita en Go que permite verificar el estado y la configuración de sistemas Linux y contenedores Docker. Utiliza archivos de especificación YAML o JSON para definir las pruebas y proporciona una sintaxis sencilla para escribir pruebas de manera legible y comprensible.

Instalación de Goss y Pruebas Simples en Sistemas Linux:

Para instalar Goss en un sistema Linux, sigue estos pasos:

1.- Descarga el binario de Goss desde el repositorio oficial:

1
curl -fsSL https://goss.rocks/install | sh

2.- Asegúrate de que el binario de Goss esté en tu PATH. Puedes moverlo a un directorio incluido en tu PATH, como /usr/local/bin:

1
sudo mv /path/to/goss /usr/local/bin/goss

3.- Verifica que Goss esté instalado correctamente ejecutando el siguiente comando:

1
2
$ goss -v
goss version v0.4.6

4.- Aquí tienes un ejemplo de cómo podrías escribir una prueba simple para verificar la existencia de un archivo:

1
2
3
4
$ cat goss.yaml
file:
  /etc/passwd:
    exists: true

5.- Guarda este contenido en un archivo YAML, por ejemplo, goss.yaml. Luego, ejecuta la prueba con el siguiente comando:

1
2
3
4
5
$ goss validate goss.yaml
.

Total Duration: 0.000s
Count: 1, Failed: 0, Skipped: 0

Esto ejecutará la prueba y te proporcionará una salida indicando si la prueba pasó o falló.

Dockerfile para Integrar Goss en un Contenedor de WordPress:

A continuación, te muestro el Dockerfile completo que incluye Goss y ejecuta pruebas antes de iniciar el contenedor de WordPress:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Utiliza la imagen base de WordPress
FROM wordpress:latest

# Instala curl (necesario para descargar Goss)
RUN apt-get update && apt-get install -y curl

# Descarga e instala Goss
RUN curl -fsSL https://goss.rocks/install | sh

# Crea un directorio para almacenar archivos de pruebas
RUN mkdir /goss

# Copia el archivo de especificación de pruebas Goss al directorio creado
COPY goss.yaml /goss/goss.yaml

# Establece el directorio de trabajo como /goss
WORKDIR /goss

# Ejecuta las pruebas Goss durante la inicialización del contenedor
CMD ["sh", "-c", "goss validate && apache2-foreground"]

Asegúrate de tener el archivo goss.yaml en el mismo directorio que tu Dockerfile.

En este Dockerfile, hemos configurado Goss para que se ejecute durante la inicialización del contenedor. Primero, se instala Goss y se copia el archivo de especificación de pruebas goss.yaml al contenedor. Luego, durante la inicialización del contenedor, se ejecutan las pruebas Goss y, si son exitosas, se inicia el servidor Apache para WordPress.

Después de definir el Dockerfile y asegurarte de que el archivo goss.yaml esté en el mismo directorio, el siguiente paso es construir la imagen Docker. Utiliza el siguiente comando para ello:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$ docker build -t mi_wordpress_con_goss:latest .
[+] Building 0.1s (11/11) FINISHED                                                                                                                                                                                            docker:default
 => [internal] load build definition from Dockerfile                                                                                                                                                                                    0.0s
 => => transferring dockerfile: 637B                                                                                                                                                                                                    0.0s
 => [internal] load metadata for docker.io/library/wordpress:latest                                                                                                                                                                     0.0s
 => [internal] load .dockerignore                                                                                                                                                                                                       0.0s
 => => transferring context: 2B                                                                                                                                                                                                         0.0s
 => [1/6] FROM docker.io/library/wordpress:latest                                                                                                                                                                                       0.0s
 => [internal] load build context                                                                                                                                                                                                       0.0s
 => => transferring context: 30B                                                                                                                                                                                                        0.0s
 => CACHED [2/6] RUN apt-get update && apt-get install -y curl                                                                                                                                                                          0.0s
 => CACHED [3/6] RUN curl -fsSL https://goss.rocks/install | sh                                                                                                                                                                         0.0s
 => CACHED [4/6] RUN mkdir /goss                                                                                                                                                                                                        0.0s
 => CACHED [5/6] COPY goss.yaml /goss/goss.yaml                                                                                                                                                                                         0.0s
 => CACHED [6/6] WORKDIR /goss                                                                                                                                                                                                          0.0s
 => exporting to image                                                                                                                                                                                                                  0.0s
 => => exporting layers                                                                                                                                                                                                                 0.0s
 => => writing image sha256:4e132c2b114e3ceb98b1c0879de38b91f7ec788ae1434aa6c3930602a27e95d3                                                                                                                                            0.0s
 => => naming to docker.io/library/mi_wordpress_con_goss:latest

Una vez que la imagen se ha construido correctamente, puedes ejecutar un contenedor basado en esta imagen utilizando el siguiente comando:

1
docker run -d -p 8080:80 mi_wordpress_con_goss:latest

Este comando ejecutará el contenedor en segundo plano (-d) y mapeará el puerto 80 del contenedor al puerto 8080 de tu máquina local (-p 8080:80).

Finalmente, para verificar los resultados de las pruebas de Goss y cualquier mensaje relacionado con la inicialización del servidor Apache, puedes revisar los registros del contenedor con el siguiente comando:

1
2
3
4
5
6
7
8
9
$ docker logs $(docker ps -q --latest)
.

Total Duration: 0.000s
Count: 1, Failed: 0, Skipped: 0
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.17.0.2. Set the 'ServerName' directive globally to suppress this message
AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 172.17.0.2. Set the 'ServerName' directive globally to suppress this message
[Sat May 11 18:22:06.122508 2024] [mpm_prefork:notice] [pid 12] AH00163: Apache/2.4.59 (Debian) PHP/8.2.19 configured -- resuming normal operations
[Sat May 11 18:22:06.122557 2024] [core:notice] [pid 12] AH00094: Command line: 'apache2 -D FOREGROUND

Esto te proporcionará información sobre si las pruebas de Goss fueron exitosas y si el servidor Apache se inició correctamente. Si las pruebas pasaron, verás un mensaje indicando que no hay fallos. Si las pruebas fallaron, el contenedor no iniciará el servidor Apache y mostrará los resultados de las pruebas en los registros del contenedor.

Forzando el error

Para simular un escenario de error, podemos modificar el archivo goss.yaml para incluir una prueba que falle. Por ejemplo, podemos verificar la existencia de un archivo que sabemos que no existe. Esto nos permitirá ver cómo el contenedor reacciona ante un fallo en las pruebas.

1
2
3
4
$ cat goss.yaml
file:
  /etc/passwd12:
    exists: true

Cuando revisamos los registros del contenedor después de ejecutar las pruebas con Goss, podemos obtener información valiosa sobre la integridad de nuestra aplicación. Por ejemplo, si encontramos un mensaje que indica que una prueba ha fallado, como el siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
$ docker logs $(docker ps -q --latest)
F

Failures/Skipped:

File: /etc/passwd12: exists:
Expected
    false
to equal
    true

Total Duration: 0.004s
Count: 1, Failed: 1, Skipped: 0

Este mensaje nos indica que la prueba de existencia del archivo importante ha fallado. Ahora, aquí viene la parte crucial: en este ejemplo, hemos configurado nuestro sistema de manera que si esta prueba falla, la aplicación no se inicia. ¿Por qué? Porque el archivo que estamos verificando es crítico para el funcionamiento de nuestra aplicación. Si este archivo no está presente, es probable que nuestra aplicación no pueda ejecutarse correctamente.

Al diseñar nuestras pruebas de esta manera, podemos utilizar Goss no solo para verificar la integridad de los archivos y servicios dentro de nuestros contenedores, sino también como un mecanismo de seguridad adicional. Si alguna parte crítica de nuestra aplicación falta o no está configurada correctamente, podemos evitar iniciar la aplicación, lo que nos permite detectar y solucionar problemas antes de que afecten a nuestros usuarios finales.

Esta capacidad de detener el inicio de la aplicación en caso de problemas con archivos o servicios críticos nos brinda una capa adicional de seguridad y confiabilidad, lo que nos permite mantener nuestros sistemas en un estado óptimo y ofrecer una experiencia de usuario consistente y confiable.

Aprende Más sobre Goss

Si estás interesado en explorar más sobre Goss y cómo aprovechar al máximo esta herramienta, te invito a consultar un artículo que realicé en el blog de Chakray. En ese artículo, nos sumergimos más profundamente en las capacidades de Goss y exploramos otras formas de configurar pruebas de integridad en entornos más complejos, como Docker Compose.

This post is licensed under CC BY 4.0 by the author.