Docker

Sitio: Facultad de Ingeniería U.Na.M.
Curso: IC511 - Internet de las Cosas, Sensores y Redes
Libro: Docker
Imprimido por: Invitado
Día: miércoles, 4 de diciembre de 2024, 23:05

1. introducción

Docker es una plataforma abierta para desarrollar, enviar y ejecutar aplicaciones. Docker le permite separar sus aplicaciones de su infraestructura para que pueda entregar software rápidamente. Con Docker, puede administrar su infraestructura de la misma manera que administra sus aplicaciones. Al aprovechar las metodologías de Docker para enviar, probar e implementar el código rápidamente, puede reducir significativamente la demora entre escribir el código y ejecutarlo en producción.

Docker se basa en "imágenes" que empaquetan aplicaciones. Cuando se ejecuta una imagen se crea un "contenedor".

Contenedores vs. Máquinas virtuales


 Docker containerized appliction blue border 2 Container vm whatcontainer 2


Los contenedores son una abstracción en la capa de la aplicación que empaqueta el código y las dependencias juntos. Varios contenedores pueden ejecutarse en la misma máquina y compartir el kernel del sistema operativo con otros contenedores, cada uno ejecutándose como procesos aislados en el espacio del usuario. Los contenedores ocupan menos espacio que las máquinas virtuales (las imágenes de contenedores suelen tener un tamaño de decenas de MB), pueden manejar más aplicaciones y requieren menos máquinas virtuales y sistemas operativos.

Las máquinas virtuales (VM) son una abstracción del hardware físico que convierte un servidor en muchos servidores. El hipervisor permite que varias máquinas virtuales se ejecuten en una sola máquina. Cada máquina virtual incluye una copia completa de un sistema operativo, la aplicación, los archivos binarios y las bibliotecas necesarios, lo que ocupa decenas de GB. Las máquinas virtuales también pueden tardar en arrancar.

¿Por qué Docker (resumen)?

  • más que solo entornos virtuales
  • entornos aislados para todas las dependencias
  • variedad de servicios
  • fáciles de desplegar
  • mismo entorno para todos los desarrolladores
  • se puede elegir la versión de python
  • etc

2. Instalación

Pasos para instalar docker en la raspberry pi

$ sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

$ echo \
"deb [arch=arm64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

$ sudo apt update
IMPORTANTE: Reiniciar el equipo
$ sudo apt install docker-ce docker-ce-cli containerd.io
Verificamos la instalación ejecutando una imagen de prueba

$ sudo docker run hello-world
Como docker no encontró la imagen "hello-world" localmente la descargo del repositorio por defecto y luego creó el contenedor.
Ahora agregamos a nuestro usuario al grupo docker para poder utilizar docker sin permisos de administrador.

$ sudo groupadd docker
$ sudo usermod -aG docker "$USER"
$ newgrp docker
Ahora podemos utilizar docker como usuario común (sin sudo)

$ docker run hello-world

Activamos docker como servicio de sistema para que se ejecute cada vez que se inicia el sistema

$ sudo systemctl enable docker.service
$ sudo systemctl enable containerd.service

Por último editamos el archivo "dhcpcd.conf" y agregamos la siguiente línea al final

$ sudo nano /etc/dhcpcd.conf

denyinterfaces veth*

Reiniciamos el servicio DHCP

$ sudo systemctl restart dhcpcd.service

3. Crear una Imagen

En el capítulo anterior utilizamos la imagen "hello-world", ahora vamos a crear nuestra propia imagen. Vamos a convertir nuestro clientemqtt a imagen de docker. Las instrucciones para crear la imagen se especifican en un archivo Dockerfile.

En la primer línea indicamos que nuestra imagen estará basada en una imagen existente de python.
Luego definimos el directorio en el cual estará nuestra aplicación dentro de la imagen.
Copiamos e instalamos los requerimientos de librerías.
Copiamos nuestra aplicación y finalmente definimos cual es el comando para ejecutar la misma.

$ git clone https://github.com/GermanXander/docker_iot.git

# branch 3a

Una vez que tenemos el archivo Dockerfile construimos la imagen

~/docker_iot/clienteMqtt $ docker build -t clientemqtt .

La opción -t es para indicar un tag o nombre de la imagen. El punto final es para indicar que el archivo Dockerfile se encuentra en directorio actual.

Ahora ejecutamos (creamos el contenedor) docker run

~/docker_iot/clienteMqtt $ docker run --rm --name cliente_mqtt clientemqtt

--rm para que elimine el contenedor cuando salimos

"cliente_mqtt" es el nombre del contenedor basado en la imagen "clientemqtt"


podemos observar que hay un error en la zona horaria. Esto lo vamos a solucionar con variables de entorno pasadas al contenedor (ENV).


Uso de Variables de entorno

# branch 3b
En Dockerfile ahora hay una línea que le pasa la variable de entorno al sistema operativo dentro de la imagen. En este caso sobreescribimos la información de zona horaria del sistema.

ENV TZ="America/Argentina/Buenos_Aires"
Ya no obtenemos la dirección del servidor y el tópico, al cual suscribirse, desde un archivo .env sino que los tomamos de las variables de entorno, llamada SERVIDOR y TOPICO, del sistema operativo. Estas variables de entorno todavía no existe al momento de construir la imagen, se las debemos pasar al momento de ejecutar (crear el contenedor). Esto se hace con el parámetro -e "variable=valor".

~/docker_iot/clienteMqtt $ docker run -e SERVIDOR=iotunam.duckdns.org -e TOPICO=temperatura --rm --name cliente_mqtt clientemqtt 
Si nuestro cliente recibe publicaciones vía mqtt quiere decir que pudimos pasar la información sobre nuestro broker. Ahora también muestra la hora/zona horaria correcta.


Contenedores en segundo plano

Si le agregamos el parámetro -d (detach) el contenedor se ejecuta en segundo plano y recuperamos el control del terminal.
Podemos ver todos los procesos de docker (contenedores) con el comando docker ps.



Para ver los registros usamos docker logs <contenedor> .



y para ver los registros en tiempo real:

~/docker_iot/clienteMqtt $ docker logs -f --tail 20 cliente_mqtt
en este caso muestro los últimos 20 registros

También podemos acceder a la consola del contenedor

$ docker exec -it cliente_mqtt /bin/bash

4. Docker compose

Docker compose es una herramienta que nos permite utilizar un archivo con la información para la creación de todos nuestros contenedores. Parámetros tales como imagen, variables de entorno, puertos, directorios, etc. se agregan de manera estructurada en una archivo .yaml (texto), generalmente compose.yaml.

Se instala con:

$ sudo apt install docker
creamos un archivo compose.yaml en el raíz de nuestro proyecto

version: "3"
services:
  clientemqtt:
    image: clientemqtt
    container_name: clientemqtt
    environment:
      - TZ=America/Argentina/Buenos_Aires 
      - SERVIDOR=${SERVIDOR} #Se reemplazará por la env var SERVIDOR defineda en .env
      - TOPICO=${TOPICO}
    restart: unless-stopped
luego "ejecutamos" con:

~/docker $ docker compose up