01 Curso Kubernetes Intro Docker

Introducción al uso de
1
contenedores y Docker www.iti.es
Juan Velasco Bermúdez (formacion@iti.es)
Curso: Kubernetes para desarrolladores Copyright 2022 Instituto Tecnológico de Informática (ITI)
Prohibida la reproducción total o parcial sin permiso de ITI
Introducción
Conceptos básicos de Docker
Introducción al uso de Dockerfiles
contenedores y Publicar imágenes Docker
Docker Docker Compose
Docker en producción
www.iti.es
Curso: Kubernetes para desarrolladores Copyright 2022 Instituto Tecnológico de Informática (ITI)
Presentaciones
§ Juan Velasco
• Jefe de proyectos en ITI
• Área de Innovación de Software
• Metodologías DevOps
• Tecnologías cloud
• Arquitectura de aplicaciones
• Symfony developer
Curso: Kubernetes para desarrolladores 3 Copyright 2022 Instituto Tecnológico de Informática (ITI)
Introducción a contenedores y Docker
§ Para poder trabajar con Kubernetes, debemos estar previamente familiarizados con
Docker, ser capaces de “empaquetar” nuestras aplicaciones en una imagen Docker
mediante el uso de Dockerfiles, así como publicar estas imágenes en un Docker
Registry.
§ En esta lección veremos cómo trabajar con Docker, utilizar imágenes de otros,
generar imágenes propias utilizando las mejores prácticas y publicarlas en un
registry.
Virtualización
§ La virtualización es la creación a través de software de una representación
(versión virtual) de algún recurso tecnológico.
§ Permite crear uno o varios entornos simulados que ejecutan en un sistema
operativo guest o invitado, que a su vez corren sobre un sistema operativo host o
anfitrión, mediante el uso de un hipervisor.
Sistema virtualizado
Hardware tradicional
Contenedores: el problema
http://disney.github.io/docker-training/#/
§ Necesitamos desarrollar aplicaciones distribuidas, que funcionen en distintos

sistemas operativos, entornos de ejecución, con diferentes dependencias o
librerías y que puedan desplegarse sobre múltiples plataformas.
El problema (analogía con el Mundo Real™)
Transporte de mercancías antes de 1956
Uso de contenedores
Docker es un sistema de contenedores para nuestro código
Uso de contenedores
Docker nos permite eliminar la "matriz infernal"
Contenedores
§ Un contenedor contiene todo lo necesario para ejecutar nuestra
aplicación: sistema operativo, código, librerías, dependencias, etc.
§ En lugar de emular el hardware, utilizan tecnologías como cgroups y
namespaces del kernel de Linux.
Virtualización
Contenedores
Contenedores
§ Ventajas
• Encapsula todas las dependencias: se acabó lo de "en local funciona"
• Aplicaciones verdaderamente portables: escríbelo una vez... (y por fin) ejecútalo
en cualquier lugar*
• Tamaño de imagen reducido
• Inicialización de un contenedor en segundos
• Apenas hay penalización de rendimiento
§ Desventajas
• No es posible ejecutar Linux sobre Windows y viceversa (se usa virtualización).
• Se comparte el kernel, por lo que el aislamiento no es total (seguridad).
*"Cualquier lugar" significa un servidor x86 (y ARM desde 2019) corriendo un kernel de Linux
moderno
Contenedores - Docker
Presentación pública de Docker en 2013
https://www.youtube.com/watch?v=wW9CAH9nSLs
§ Pero no todo es Docker, existen más tecnologías:

• Linux Containers (LXC/LXD) - https://linuxcontainers.org/
• Containerd (runtime) - https://containerd.io/
• Podman (alternativa a Docker) - https://podman.io/
• RKT (abandonado) - https://github.com/rkt/rkt/
Docker – Conceptos básicos
• Imagen
• Contiene una distribución del sistema operativo junto con las dependencias
necesarias (paquetes, aplicaciones, datos,..) que permiten ejecutar la
aplicación.
• Contenedor
• Es una instancia de la imagen, que se ejecuta como un proceso dentro de una
máquina concreta (Docker Host).
• Volumen
• Directorio o un fichero en el Docker Engine que se monta en el contenedor.
Permite conservar los datos cuando el contenedor finaliza.
• Docker Host
• La máquina (que puede ser física o virtual) que tiene instalado Docker Engine
y se encarga de ejecutar los contenedores.
Docker – Conceptos básicos
• Docker Client
• Normalmente será la misma máquina que el Docker Host (pero no tiene por
qué ser así). Es la herramienta con la que ejecutamos los comandos "docker
run", "docker-compose up", etc.
• DOCKER_HOST=“ssh://user@remotehost” docker-compose up –d
• Docker Registry
• Repositorio de imágenes, es accesible mediante interfaz web, línea de
comandos o mediante API REST.
• Existen tanto registros públicos como privados.
• https://hub.docker.com/
• https://azure.microsoft.com/es-es/services/container-registry/
• https://aws.amazon.com/es/ecr/
Dockerfiles
§ ¿Qué es un Dockerfile?
• Es un archivo de texto simple con un conjunto de comandos.
• Estos comandos se ejecutan de forma sucesiva para realizar acciones en la imagen base (indicada
con FROM) y así crear una nueva imagen.
FROM ubuntu:22.04
RUN apt update -y \

§ Explicación
&& apt install -y python3 • Siempre partimos de una imagen base con FROM
• Lanzamos comandos con RUN
WORKDIR /app • Usamos WORKDIR para cambiar el directorio actual
• Podemos copiar ficheros a la imagen con COPY
COPY hello.py ./
• CMD define el comando que ejecutará la imagen
CMD python3 hello.py
Ejercicio: creación de un Dockerfile
§ Utilizando el repositorio del enlace, vamos a crear nuestra propia imagen Docker
§ Simplemente, tendremos que ejecutar los comandos siguientes:
git clone https://github.com/juan-velasco/01_ejercicio_dockerfile.git

cd 01_ejercicio_dockerfile
docker build -t hello-world-python:1.0.0 .
docker run --rm hello-world-python:1.0.0 ¡Atención al punto!
https://github.com/juan-velasco/01_ejercicio_dockerfile
Comandos básicos de un Dockerfile
§ FROM nos permite definir la imagen desde la que partimos
• FROM ubuntu:22.04
§ RUN se utiliza para ejecutar comandos en el sistema operativo
• RUN apt-get install nginx
§ COPY copia archivos de la máquina host a la imagen Docker (se copian al generar la
imagen, no al levantar el contenedor).
• COPY index.html /usr/share/nginx/html
§ ADD es similar a COPY, pero permite obtener los ficheros desde una url.
• ADD http://example.com/index.html /usr/share/nginx/html
§ WORKDIR permite establecer el directorio de trabajo dentro de la imagen (equivale
a hacer “cd <ruta>”.
• WORKDIR /usr/share/nginx/html
https://docs.docker.com/engine/reference/builder/
§ EXPOSE se utiliza para exponer un puerto. Por ejemplo el 80 para un servidor web.
• EXPOSE 80
§ LABEL sirve para agregar metadatos a la imagen
• LABEL "website.name"="my website"
§ ENV permite establecer variables de entorno
• ENV MY_PASSWORD=“123456”
§ ARG permite establecer argumentos que podremos modificar durante la
construcción de la imagen
• ARG MY_PASSWORD=“123456”
• Luego lo podemos sobrescribir al hacer el build:
• docker build --build-arg MY_PASSWORD=654321 -t mysql:5.7 .
§ CMD permite ejecutar el comando que es el que se quedará ejecutando en el

contenedor. Es posible también lanzar un script para que se ejecuten varios
comandos.
• CMD node app.js
Cómo funcionan las capas en las imágenes Docker
§ Cuando generamos una imagen Docker a partir de otra con FROM, lo que se hace
internamente es agregar una serie de “capas” que se van apilando unas sobre otras.
§ Debemos tener esto en cuenta a la hora de generar nuestras imágenes. La buena
práctica es “Cuantas menos capas, mejor”.
§ Docker se encargará de reutilizar las capas siempre que sea posible.
§ Cada comando es una nueva capa, por lo que es habitual concatenar comandos de
esta manera:
RUN apt update -y \

&& apt install -y python3
https://vsupalov.com/docker-image-layers/
Buenas prácticas al crear Dockerfiles
§ Los comandos deben ser desatendidos: -y, --yes, --no-interaction, --force
§ El servicio debe ser efímero (descartable en cualquier momento).
§ Debe haber un único proceso por imagen (un único CMD).
§ Usaremos .dockerignore para excluir los ficheros y directorios del proyecto que no
sean necesarios en la imagen.
§ Usaremos el mínimo número de capas, por ejemplo, concatenando comandos y
usando comandos multilínea.
§ Evitaremos paquetes innecesarios como curl, nano, etc.
§ Usaremos Multi-stage builds siempre que sea posible.
https://docs.docker.com/engine/reference/builder/#dockerignore-file
https://docs.docker.com/develop/develop-images/multistage-build/
Multi-stage builds
§ Utilizando multi-stage builds, podemos levantar una imagen que realice un proceso
(por ejemplo una compilación) y luego pasar el resultado a una imagen diferente.
§ El uso de builds multi-stage nos permite publicar imágenes mucho más ligeras, ya
que contienen únicamente el “producto final”.
FROM maven:3.5 AS builder

WORKDIR /app
COPY src ./
RUN mvn package
FROM openjdk:8
COPY --from=builder /app/target/my-app.jar /opt/app.jar
CMD java -jar /opt/app.jar
Ejercicio: Dockerfile multi-stage
§ Utilizando el repositorio del enlace, vamos a crear una imagen Docker.

§ Tendremos que ejecutar los comandos siguientes:
git clone https://github.com/juan-velasco/02_ejercicio_multi_stage.git

cd 02_ejercicio_multi_stage
¡Atención al punto!
docker build -t my-vue-app:1.0.0 .
docker run --rm -d -p 8088:80 --name=app_vue my-vue-app:1.0.0
Y ahora en el navegador abrimos http://localhost:8088
https://github.com/juan-velasco/02_ejercicio_multi_stage
Docker registry
§ Un Docker Registry es un sistema de almacenamiento y distribución de imágenes

Docker.
§ Pueden ser públicos, como por ejemplo DockerHub, o privados.
§ Algunos ejemplos de Docker Registry:
• Gitlab Container Registry
• Github Container Registry
• Amazon Elastic Container Registry
• Azure Container Registry
• Jfrog Container Registry
Alta en DockerHub
§ Para publicar en un registry, necesitaremos evidentemente tener una cuenta.
Podemos crearnos una cuenta de forma gratuita en Dockerhub.
Subiendo nuestra imagen al registry
§ Para hacer uso de un registry desde la línea de comandos, necesitaremos hacer

login en el mismo con el comando “docker login”.
§ Antes de subir una imagen debemos “taguearla” incluyendo nuestro repositorio o
cuenta de DockerHub. Las imágenes con nombres sin prefijos están reservadas a
imágenes oficiales.
docker tag my-vue-app:1.0.0 jvelascoiti/my-vue-app:1.0.0
§ Ahora podemos hacer uso del comando “docker push” para subir la imagen al
repositorio.
docker push jvelascoiti/my-vue-app:1.0.0
Subiendo nuestra imagen al registry
§ La imagen debería aparecer en la interfaz web del registry:
Docker Compose
§ Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker

basadas (casi siempre) en más de un contenedor.
§ Utiliza un fichero de configuración YAML para definir una serie de servicios de
aplicación.
§ Permite administrar:
• Contenedores
• Imágenes
• Volúmenes
• Redes
• Variables de entorno
Ejemplo de un fichero Docker Compose
§ En este ejemplo estamos montando un Elasticsearch (motor de búsqueda y

analítica) junto con un Kibana, que es la interfaz web que nos permite conectar
con el mismo y visualizar los datos
version: '3.3’
services:
elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:7.12.0
container_name: elasticsearch
ports:
- '9200:9200’
- '9300:9300’
volumes:
- 'elasticsearch_data:/usr/share/elasticsearch/data’
kibana:
image: docker.elastic.co/kibana/kibana:7.12.0
container_name: kibana
ports: ['5601:5601’]
depends_on: ['elasticsearch’]
volumes:
elasticsearch_data:
Elementos principales de un docker-compose.yml
§ version (requerido)
• Indica la versión del formato del fichero Docker-compose (usaremos la versión 3.8)
§ services (requerido)
• En este bloque definiremos los contenedores Docker que vamos a levantar
§ volumes (opcional)
• Volúmenes, que permiten persistir ficheros cuando se destruye el contenedor
§ networks (opcional)
• Utilizaremos redes para configurar la forma en que los contenedores se ven entre sí, con la
máquina host u otras máquinas
https://docs.docker.com/compose/compose-file/#compose-file
Comandos principales con Docker Compose
§ docker-compose up
• Lo utilizaremos para poner en marcha los contenedores, así como crear los volúmenes o redes
asociadas cuando corresponda. Con la opción “-d” nos devolverá la consola.
§ docker-compose down
• Finaliza la ejecución de los contenedores. Borrará los contenedores además de pararlos
§ docker-compose restart
• Reinicia los contenedores asociados al docker-compose.yml
§ docker-compose logs
• Visualiza los logs generados por los contenedores
§ docker-compose build
• Relanza el comando build de la imagen para los casos en que usamos un Dockerfile personalizado.
https://docs.docker.com/compose/reference/
Ejercicio: Docker Compose
§ Utilizando el repositorio del enlace, vamos a lanzar una aplicación Python que hace
uso de una base de datos Redis.
§ Simplemente tenemos que ejecutar los comandos siguientes:
git clone https://github.com/juan-velasco/03_ejercicio_docker_compose.git

cd 03_ejercicio_docker-compose
docker-compose up -d
Y ahora en el navegador abrimos http://localhost:8090/

Con “docker-compose logs -f” podemos ver los logs que generan las peticiones.
Finalizamos la ejecución con “docker-compose down”
https://github.com/juan-velasco/03_ejercicio_docker_compose
Docker en producción
§ Podemos utilizar un docker-compose.yml para utilizar Docker en producción
• https://docs.docker.com/compose/production/
§ Configuraremos “restart: always” para que el contenedor se reinicie
automáticamente en caso de cuelgue o reinicio del servidor.
§ Lo ideal es publicar una imagen ya compilada y específica para producción.
También podemos tener más de un fichero docker-compose.yml o usar ”override”.
• docker compose -f docker-compose-prod.yml up
• https://docs.docker.com/compose/extends/
§ Es posible desplegar de forma remota utilizando DOCKER_HOST o Contexts
• https://docs.docker.com/engine/context/working-with-contexts/
§ Quizás nos interese limitar los recursos de CPU o memoria que puede utilizar cada
contenedor
• https://docs.docker.com/config/containers/resource_constraints/
Camino de Vera, s/n CPI-UPV
Ed/ Bldg. 8G Acc. B – Nivel 4 / 4th Floor
46022 Valencia – España/Spain
Telf.: +34 96 387 70 69
www.iti.es

01 Curso Kubernetes Intro Docker

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

01 Curso Kubernetes Intro Docker

Cargado por

Copyright:

Formatos disponibles

Introducción al uso de

Juan Velasco Bermúdez (formacion@iti.es)

§ Necesitamos desarrollar aplicaciones distribuidas, que funcionen en distintos

Transporte de mercancías antes de 1956

Docker es un sistema de contenedores para nuestro código

Docker nos permite eliminar la "matriz infernal"

§ Pero no todo es Docker, existen más tecnologías:

RUN apt update -y \

git clone https://github.com/juan-velasco/01_ejercicio_dockerfile.git

§ CMD permite ejecutar el comando que es el que se quedará ejecutando en el

RUN apt update -y \

FROM maven:3.5 AS builder

§ Utilizando el repositorio del enlace, vamos a crear una imagen Docker.

git clone https://github.com/juan-velasco/02_ejercicio_multi_stage.git

Y ahora en el navegador abrimos http://localhost:8088

§ Un Docker Registry es un sistema de almacenamiento y distribución de imágenes

§ Para hacer uso de un registry desde la línea de comandos, necesitaremos hacer

§ La imagen debería aparecer en la interfaz web del registry:

§ Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker

§ En este ejemplo estamos montando un Elasticsearch (motor de búsqueda y

git clone https://github.com/juan-velasco/03_ejercicio_docker_compose.git

Y ahora en el navegador abrimos http://localhost:8090/

Finalizamos la ejecución con “docker-compose down”

También podría gustarte