Docker

Los rulebooks de Clarive requieren Docker instalado para ejecutar comandos shell del SO.

Docker es un gran compañero para su stack DevOps:

Los contenedores Docker permiten que los rulebooks de su proyecto y repositorio ejecuten pipelines junto con cualquier infraestructura necesaria sin requerir que se instalen paquetes de software adicionales en el servidor Clarive.
Aísle a sus usuarios del entorno del servidor, para que no puedan romper nada.
Versione los paquetes de su infraestructura, para que diferentes versiones de una aplicación puedan ejecutar diferentes versiones de una imagen.
Simplifique su stack DevOps teniendo la mayoría de sus flujos de trabajo de entrega continua build-test-deploy ejecutándose en un servidor (o más, si tiene un clúster de servidores Clarive), en lugar de tener que instalar runners para cada proyecto en todas partes.

La imagen de contenedor Docker predeterminada¶

Cuando ejecuta un op shell: o una de sus variaciones, Clarive ejecutará el comando shell en un contenedor Docker.

Si no especifica el nombre de la imagen, Clarive ejecutará docker pull de una imagen Docker desde Docker Hub llamada clarive/rulebook-runner que está disponible aquí.

Especificar la `image:`¶

El op image: del rulebook configura qué imagen de contenedor Docker será usada por Clarive para ejecutar comandos.

# establece la imagen python como predeterminada para todo el rulebook

image: python
do:
   - python --version  # esto se ejecutará en el contenedor python

También puede cambiar imágenes en línea.

do:
   - image: python
   - python --version  # esto se ejecutará en el contenedor python

Cuando use una imagen por primera vez, puede tomar desde unos segundos hasta unos minutos (dependiendo de su conexión a internet) para que Clarive haga docker pull y docker build de la versión de su imagen que se usará en su rulebook.

Cómo se ejecutan los comandos shell¶

Cada comando shell en un rulebook se ejecuta dentro de bash con un comando docker run.

Esto es importante ya que significa que el contenedor inicia y termina con cada comando.

Si necesita ejecutar una secuencia estable de comandos, simplemente ejecútelos como un solo comando:

do:
    - image: python
    - |
         echo "print(123)" > /clarive/my.py
         python /clarive/my.py
         cd /tmp/
         ls -lart

Volúmenes disponibles¶

Los volúmenes son los directorios mapeados desde el host al contenedor invitado usando la opción de línea de comandos docker run -v.

Cada sesión de contenedor tiene la siguiente estructura de directorios disponible como volúmenes individuales:

 /clarive/
 /clarive/.public     # archivos compartidos entre todos los proyectos
 /clarive/.artifacts  # los archivos aquí se cargan en el repositorio de artefactos de Clarive

Si usa el op workspace: para clonar repositorios git de sus proyectos, habrá carpetas adicionales mapeadas dentro. Por ejemplo:

  /clarive/myproject/myrepo

Establecer el usuario del contenedor¶

Cada comando shell enviado se ejecuta usando el usuario clarive predeterminado.

Para ejecutar comandos con un usuario diferente, pase el parámetro user: al op image:.

image:
  name: python
  user: root
do:
  - whoami     # root

El usuario se envía con la opción de línea de comandos docker run -u|--user. Esta opción toma el argumento así: user|uid[:group:gid].

image:
  name: python
  user: "0:0"   # esto también funciona
do:
  - whoami     # root otra vez

O establezca un usuario diferente para cada comando y contenedor:

do:
  - image:
      name: python
      user: root
      do:
         - whoami

  - image:
      name: ruby
      user: rubyuser
      do:
         - whoami

Establecer la versión de la imagen del contenedor¶

Puede establecer la versión de la imagen del contenedor en el nombre:

do:
   - image: "python:latest"   # latest es en realidad el predeterminado
   - python --version
   - image: "ruby:1.7.2"

Establecer el ejecutor shell del contenedor¶

Puede establecer el ejecutor shell de la imagen del contenedor con la opción runner:

do:
     - image:
         name: python
         runner: bash       # o cualquier otro shell
     - pwd

O puede especificar la imagen fuera del bloque do:

image:
  name: python
  runner: bash       # o cualquier otro shell
do:
  - pwd

Establecer variables de entorno del contenedor¶

Puede enviar variables de entorno al contenedor.

image:
  name: python
  environment:
      MY_DIR: "/tmp"
do:
   - ls -lart $MY_DIR

   # o, si quiere usar la notación ${} en un shell bash
   # necesita escaparla con doble signo de dólar `$${}`

   - ls -lart $${MY_DIR}

O para un ejemplo más avanzado usando serverless y AWS, usando variables definidas mediante la interfaz de administración de Variables:

image:
  name: laardee/serverless
  environment:
      AWS_ACCESS_KEY_ID: "{{ ctx.var('aws_key') }}"
      AWS_SECRET_ACCESS_KEY: "{{ ctx.var('aws_secret') }}"
do:
   - serverless deploy

El Dockerfile predeterminado¶

Clarive no usa la imagen Docker que establece en image: tal como está.

Después de descargar la imagen del contenedor desde Docker Hub, Clarive ejecuta docker build para crear una nueva versión de la imagen con un Dockerfile específico de clarive.

ARG image_name
FROM $image_name
ARG UID
RUN useradd -ms /bin/bash -u $UID clarive ; exit 0
RUN adduser -s /bin/bash -u $UID clarive ; exit 0

USER clarive
ARG workspace_dir
WORKDIR $workspace_dir

Esto es para que siempre ejecutemos Clarive con el mismo usuario dentro de esa imagen.

Las imágenes que se construyen usando este Dockerfile se renombran clarive/imagename....

Si absolutamente debe modificar el Dockerfile estándar de Clarive a su gusto, agregue las siguientes claves a su CLARIVE_BASE/config/yourconfig.yml:

docker:
    dockerfile: "path/to/your/dockerfile_folder/"  # <--- Dockerfile debe residir en esta carpeta

Note

Solo puede modificar el Dockerfile en la versión on-prem de Clarive. La versión en la nube está restringida al Dockerfile estándar.

Ejecutar comandos en otros servidores¶

Clarive usa Docker para ejecutar comandos shell localmente.

Pero aún puede ejecutar comandos shell en otros servidores y sistemas, como Linux, Windows, varios sabores de Unix y otros sistemas legacy (¡incluido el mainframe!) usando la opción host: en el comando shell:.

deploy:
    - shell:
         cmd: `service mariadb restart`
         host: "dbserver1"

Esto ejecutará un comando en ese servidor usando una conexión de recurso de nodo predefinida o con un agente/worker clax.

Para configurar un nodo, use la interfaz de administración de la interfaz de usuario de Resources.

Cómo uso mis propios contenedores¶

Si el contenedor no está disponible en el servidor Clarive, el rulebook de Clarive descarga el contenedor desde Docker Hub.

Entonces, para usar sus propios contenedores, tiene 2 opciones:

súbalos a Docker Hub. Luego úselos desde su rulebook. Clarive lo descargará en la primera ejecución.
[solo on-premise] instálelo en su servidor Clarive. En la primera ejecución, Clarive construirá otra versión de su contenedor basada en el Dockerfile predeterminado de Clarive, llamado clarive/yourcontainer. No necesita prefijar clarive/ en el nombre, eso se hace automáticamente.

Roadmap

¡Pronto lanzaremos un registro de contenedores integrado en Clarive. ¡Así que manténgase atento!