Antes de ver los laboratorios de infra y Docker Compose, entendamos qué es Docker y las características de la contenerización.
Docker es una plataforma que permite a los desarrolladores desarrollar, enviar y ejecutar aplicaciones en contenedores. Los contenedores te permiten empaquetar una aplicación con todas sus dependencias en una unidad estándar para el desarrollo de software. Docker proporciona herramientas y una plataforma para gestionar estos contenedores de manera eficiente.
Aquí están los componentes clave de Docker:
- Motor Docker (Docker Engine): El componente principal de Docker. Es una herramienta de empaquetado y tiempo de ejecución ligera para contenedores. Docker Engine te permite crear, gestionar y ejecutar contenedores en una máquina anfitriona.
- Imagen de Docker (Docker Image): Un paquete inmutable, independiente y ejecutable que contiene todas las dependencias necesarias (bibliotecas, binarios, código, entorno de ejecución, etc.) para ejecutar una aplicación. Las imágenes son los bloques de construcción de los contenedores.
- Contenedor Docker (Docker Container): Una instancia de una imagen Docker que se ejecuta como un proceso en el sistema operativo de la máquina anfitriona. Los contenedores son entornos ligeros, portátiles y aislados que ejecutan aplicaciones.
Más info:
Índice:
Docker Compose
Docker Compose es una herramienta que te permite definir y ejecutar aplicaciones Docker de múltiples contenedores utilizando un archivo YAML para configurar servicios, redes y volúmenes, simplificando la gestión de aplicaciones complejas y sus dependencias.
Un archivo Docker Compose (docker-compose.yml) define la configuración de los servicios de tu aplicación, incluyendo secciones de servicios, redes y volúmenes.
A continuación, se muestra un ejemplo de configuración de nginx y MySQL en un archivo docker-compose con algunas explicaciones comentadas.
version: '3.8' # Versión del formato del archivo Docker Compose
services: # Define los servicios/contenedores en tu aplicación
web: # Nombre del servicio
image: nginx:alpine # Imagen Docker a utilizar para este servicio
ports:
- "8080:80" # Mapea el puerto 8080 en el anfitrión al puerto 80 en el contenedor
volumes:
- ./nginx.conf:/etc/nginx/nginx.conf # Monta un archivo local en el contenedor
networks:
- my-network # Especifica la red a la que debe conectarse el contenedor
db: # Otro servicio para la base de datos
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: example # Variables de entorno para el contenedor
volumes:
- db-data:/var/lib/mysql # Monta un volumen para persistir datos
networks:
- my-network
networks: # Define redes para tu aplicación
my-network: # Nombre de la red
driver: bridge # Especifica el controlador de la red
volumes: # Define volúmenes para tu aplicación
db-data: # Nombre del volumen
Explicación del archivo Docker Compose:
version: Especifica la versión del formato del archivo Docker Compose.services: Define los servicios/contenedores en tu aplicación, con cada servicio compuesto por opciones de configuración como imagen, puertos, volúmenes, variables de entorno, etc.networks: Define redes para tu aplicación, permitiendo la comunicación entre contenedores.volumes: Define volúmenes para tu aplicación, permitiéndote persistir datos a través de reinicios de contenedores.
Este archivo Docker Compose especifica dos servicios (web utilizando la imagen de Nginx, exponiendo el puerto 8080, montando un archivo de configuración local, y db utilizando la imagen de MySQL, configurando variables de entorno, persistiendo datos con un volumen), una red (my-network) y un volumen (db-data), con ambos servicios conectándose a my-network.
Puedes ejecutar el comando docker-compose up en el directorio que contiene el archivo docker-compose.yml para iniciar tu aplicación definida en el archivo Docker Compose. De manera similar, puedes usar docker-compose down para detener y eliminar los contenedores.
Laboratorios de infra con docker compose
Ahora vamos a ver algunas herramientas de microservicios acompañadas de sus archivos Docker Compose. Estos se pueden utilizar para la configuración local e integrarse en un proyecto.
En cada herramienta pongo la referencia de una carpeta del repositorio Curso-lenguaje-python donde he creado cada uno de los laboratorios de infra para que funcionen con unos pequeños programas en Python.
Redis
Redis, anteriormente de código abierto y ahora «disponible bajo licencia de código fuente», sirve como una base de datos distribuida en memoria de clave-valor, caché y broker de mensajes, ofreciendo durabilidad opcional.
version: '3.6'
services:
redis:
container_name: redis-container
image: "redis:alpine"
hostname: redis
ports:
- "6379:6379"
networks:
- app-network
networks:
app-network:
driver: bridge
Laboratorio «Crear una API Caching con Redis, Flask y Docker»
RabbitMQ
RabbitMQ es un software de broker de mensajes de código abierto que inicialmente soportaba el Protocolo Avanzado de Colas de Mensajes (AMQP) pero ahora incluye una arquitectura de complementos para otros protocolos como el Protocolo de Mensajería Orientado a Texto en Streaming (STOMP) y el Transporte de Telemetría de MQ (MQTT).
version: "3.2"
services:
rabbitmq:
image: rabbitmq:3-management
container_name: 'rabbitmq-container'
hostname: rabbitmq
ports:
- 5672:5672
- 15672:15672
volumes:
- ~/.docker-conf/rabbitmq/data/:/var/lib/rabbitmq/
- ~/.docker-conf/rabbitmq/log/:/var/log/rabbitmq
networks:
- rabbitmq_go_net
networks:
rabbitmq_go_net:
driver: bridge
Laboratorio «Pruebas con rabbitmq»
Apache Kafka
Una plataforma distribuida de almacenamiento de eventos y procesamiento de flujos.
version: "2"
services:
zookeeper:
image: docker.io/bitnami/zookeeper:3.8
ports:
- "2181:2181"
volumes:
- "zookeeper_data:/bitnami"
environment:
- ALLOW_ANONYMOUS_LOGIN=yes
kafka:
image: docker.io/bitnami/kafka:3.3
ports:
- "9092:9092"
volumes:
- "kafka_data:/bitnami"
environment:
- KAFKA_CFG_ZOOKEEPER_CONNECT=zookeeper:2181
- ALLOW_PLAINTEXT_LISTENER=yes
depends_on:
- zookeeper
volumes:
zookeeper_data:
driver: local
kafka_data:
driver: local
Laboratorio «Empezando con Apache Kafka en Python»
Elastic Stack (Elasticsearch, Logstash, Kibana)
Un conjunto de herramientas que pueden recopilar datos de manera segura y confiable desde cualquier fuente, en cualquier formato, y luego permitirte buscarlos, analizarlos y visualizarlos en tiempo real.
version: '3'
services:
elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:7.15.2
container_name: elasticsearch
environment:
- discovery.type=single-node
ports:
- "9200:9200"
networks:
- elastic
kibana:
image: docker.elastic.co/kibana/kibana:7.15.2
container_name: kibana
environment:
ELASTICSEARCH_URL: http://elasticsearch:9200
ports:
- "5601:5601"
networks:
- elastic
logstash:
image: docker.elastic.co/logstash/logstash:7.15.2
container_name: logstash
volumes:
- ./logstash-config/:/usr/share/logstash/pipeline/
environment:
LS_JAVA_OPTS: "-Xmx256m -Xms256m"
ports:
- "5000:5000"
- "9600:9600"
networks:
- elastic
sample_data:
image: docker.elastic.co/beats/metricbeat:7.15.2
container_name: sample_data
command: metricbeat -e -E output.elasticsearch.hosts=["elasticsearch:9200"]
depends_on:
- elasticsearch
networks:
- elastic
networks:
elastic:
Nota: Puedes encontrar errores al usar Elastic Stack debido a la dependencia de Java JDK.
Laboratorio «Cómo Usar Elasticsearch en Python con Docker»
Prometheus y Grafana
Grafana y Prometheus son herramientas líderes en monitoreo y análisis de aplicaciones, con Prometheus siendo una plataforma de código abierto para monitoreo y alertas que recopila y almacena métricas como datos de series temporales, y Grafana como una aplicación web de código abierto para análisis y visualización interactiva.
version: '3'
volumes:
prometheus-data:
driver: local
grafana-data:
driver: local
services:
prometheus:
image: prom/prometheus:latest
container_name: prometheus
ports:
- "9090:9090"
volumes:
- ./config/prometheus.yml:/etc/prometheus/prometheus.yml
- prometheus-data:/prometheus
restart: unless-stopped
command:
- "--config.file=/etc/prometheus/prometheus.yml"
networks:
- monitoring
grafana:
image: grafana/grafana-oss:latest
container_name: grafana
ports:
- "3000:3000"
volumes:
- grafana-data:/var/lib/grafana
restart: unless-stopped
networks:
- monitoring
cadvisor:
image: gcr.io/cadvisor/cadvisor:v0.45.0
container_name: cadvisor
ports:
- "8080:8080"
volumes:
- /:/rootfs:ro
- /var/run:/var/run:ro
- /sys:/sys:ro
- /var/lib/docker/:/var/lib/docker:ro
- /dev/disk/:/dev/disk:ro
devices:
- /dev/kmsg
restart: unless-stopped
privileged: true
networks:
- monitoring
node_exporter:
image: quay.io/prometheus/node-exporter:latest
container_name: node_exporter
command:
- '--path.rootfs=/host'
pid: host
restart: unless-stopped
volumes:
- '/:/host:ro,rslave'
networks:
- monitoring
networks:
monitoring:
Laboratorio «Configuración de Grafana con Prometheus para proyectos Python usando Docker»
SonarQube
SonarQube, desarrollado por SonarSource, es una plataforma de código abierto para la inspección continua de calidad de código, revisando automáticamente el código con análisis estático para identificar errores y malos olores de código en 29 lenguajes de programación.
version: '3'
services:
sonarqube:
image: sonarqube:latest
container_name: sonarqube
ports:
- "9000:9000"
environment:
- SONARQUBE_JDBC_URL=jdbc:postgresql://sonarqube-db:5432/sonar
- SONARQUBE_JDBC_USERNAME=sonar
- SONARQUBE_JDBC_PASSWORD=sonar
networks:
- sonarnet
depends_on:
- sonarqube-db
sonarqube-db:
image: postgres:alpine
container_name: sonarqube-db
environment:
- POSTGRES_USER=sonar
- POSTGRES_PASSWORD=sonar
- POSTGRES_DB=sonar
networks:
- sonarnet
networks:
sonarnet:
driver: bridge
Laboratorio «SonarQube Python Analysis con Docker»
Conclusión
Puede que encuentres desafíos al instalar Docker en tu sistema o que encuentres errores con el archivo Docker Compose. Trabajar con microservicios e integración puede ser complicado al principio, pero una vez que entiendes cómo usar esta herramienta, se vuelve pan comido.
Disfruta de los laboratorios del repositorio 🙂
