Este capítulo cubre nuevos comandos de Docker y detalles sobre cómo compartir datos entre el sistema anfitrión y las aplicaciones en contenedor. Aprende cuándo y cómo usar volúmenes persistentes y acceder a sistemas de archivos del host.

Comandos intermedios de Docker

Ayuda de un vistazo

Contenedores existentes

Limpieza automática del contenedor

Montar el sistema de archivos del host

Pasar un archivo a un contenedor en ejecución

Se va, pero no se olvida

Métodos distintos, mismo resultado

Volúmenes persistentes

Crear un volumen de contenedor

Contenedores diferentes, mismo volumen

Comandos y sistemas de archivos

Aprende a exponer servicios de red en Docker, crear redes de Docker y usar Dockerfiles para mantener la configuración de red.

Repaso de redes

¿Cuál es mi IP?

Puertos válidos

Hacer disponibles los servicios de red en Docker

Mapear un puerto

¿Varios contenedores, mismo puerto del host?

Exponer puertos con Dockerfiles

¡Cuántas opciones!

Asignar un puerto del contenedor

Usar mapeo efímero

Redes de Docker

Crear una red de Docker

Añadir contenedores a una red

Rangos IP

Eliminar redes de contenedores

Redes

Aprende a usar las herramientas avanzadas de gestión y compilación de imágenes de Docker para crear imágenes de contenedor compactas y eficaces. Crea imágenes multiplataforma capaces de ejecutarse en diferentes arquitecturas de procesador.

Optimizar imágenes de Docker

Controla tus preocupaciones

Exploración de imágenes de Docker

Determinar la mejor imagen a usar

Entender las capas

Pastel de capas

¿Cuántas capas?

Compilaciones multietapa

package main
import "fmt"

func main() {
  fmt.Println("Application running...")
}


FROM golang:1.21-alpine3.19
WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

CMD ["/bin/app_runner"]


Run the following commands:
  - docker build . -t single-stage-app
  - docker run single-stage-app
  - docker images
Check the size of the single-stage-app image


Compilación de una sola etapa

FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY /src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


FROM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Build the go application from source code
RUN go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following commands in the terminal:

- docker build . -t multi-stage-app
- docker run multi-stage-app
- docker images

Check the size of the single-stage-app and multi-stage-app
containers.


Compilación multietapa

Pasos de compilación del motor de Docker

Comprender las compilaciones multi-stage

Compilaciones multiplataforma

Orden de una compilación multiplataforma

Pasos multiplataforma

#!/bin/bash

# Note this is an example of string concatenation in jq
#
# There is not a Platform attribute returned by docker image inspect
# so we create our own. This is simply a string returned as Platform,
# consisting of the .Os attribute and the .Architecture attribute joined
# with a slash to produce the Platform field.
#
# This is outside the realm of the course, but is hopefully a further
# example of the power available within the jq tool.

docker image inspect multi-platform-app | jq '.[0] | {Platform: (.Os + "/" + .Architecture)}'


# Update the FROM line to support a multi-platform build
FROM ____=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
____ TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM ____

# Update with name of previous build stage
COPY --from=____ /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


# Update the FROM line to support a multi-platform build
FROM --platform=$BUILDPLATFORM golang:1.21-alpine3.19 AS gobuild

WORKDIR /src
COPY src/main.go /src/main.go

# Define the option to pull environment variables from the host
ARG TARGETOS TARGETARCH

# Build the go application from source code
RUN env GOOS=$TARGETOS GOARCH=$TARGETARCH go build -o /bin/app_runner /src/main.go

# Create application in standalone container
# Update with the image name from instructions

FROM scratch

# Update with name of previous build stage
COPY --from=gobuild /bin/app_runner /bin/app_runner

CMD ["/bin/app_runner"]


Update the Dockerfile as shown in the example.

Once complete, run the following command in the terminal:

- docker buildx build --platform linux/arm64 . -t multi-platform-app 

Verify the platform image built as expected by running the command:

./check_platform.sh

in the terminal window and verify that it returns "linux/arm64"


Compilación multiplataforma

Compilación avanzada de imágenes de contenedor

Combina las capacidades de volúmenes, redes y gestión de contenedores de Docker en aplicaciones multicontenedor usando Docker Compose. Actualiza y gestiona despliegues de aplicaciones mediante el archivo docker-compose.yml.

Introducción a Docker Compose

Gestionar una aplicación con Docker Compose

Solucionar problemas al iniciar la aplicación

Crear archivos compose.yaml

Escribir un archivo compose.yaml

Identificar secciones

¿Cuántos recursos hay?

Dependencias y resolución de problemas en Docker Compose

Cálculo de dependencias

Orden de apagado

Solución de problemas de dependencias

Crear un servicio de datos dentro de Docker

Crear un backend de servicio de datos

Añadir un cliente de datos

Usar Docker Compose para definir una aplicación completa

¡Enhorabuena!

Docker Compose

Este curso amplía los fundamentos de Docker y la contenedorización del curso de Introducción a Docker. Profundizamos en los conceptos y herramientas vistos allí, añadiendo gestión y optimización de imágenes de contenedor, redes, comunicación del sistema de archivos, y aplicaciones multiplataforma y multicontenedor. Al finalizar, serás capaz de:

- Crear compilaciones multi-stage para optimizar el tamaño, la seguridad y la reutilización de aplicaciones en contenedores.
- Usar las herramientas y conceptos de redes de Docker para añadir comunicaciones entre contenedores y ofrecer servicios de red a la red local y al exterior.
- Compartir archivos y datos entre contenedores y la máquina anfitriona usando montajes de sistema de archivos y volúmenes de Docker.
- Crear despliegues de aplicaciones multicontenedor con Docker Compose, simplificando drásticamente la configuración de herramientas complejas comunes en entornos de ciencia de datos e ingeniería.

Aprovecharás al máximo este curso si ya has trabajado con contenedores sencillos y has creado algunos, pero quieres ampliar tu caja de herramientas de desarrollo, pruebas y distribución. Nos encantará acompañarte en tu camino de aprendizaje de Docker.

Este curso amplía los conocimientos adquiridos en el curso Introducción a Docker, profundizando en los conceptos y herramientas de contenedorización. Exploraremos temas avanzados como la gestión de imágenes de contenedores, las redes, la comunicación entre sistemas de archivos y el desarrollo de aplicaciones multiplataforma y multicontenedor.
<h2>Optimización de aplicaciones en contenedores</h2>
Aprende a crear compilaciones de varias etapas para mejorar el tamaño, la seguridad y la reutilización de las aplicaciones en contenedores. A través de ejercicios prácticos, domina las técnicas para optimizar las imágenes de contenedores, garantizando una implementación y gestión eficientes en diversos entornos.
<h2>Mejora de las implementaciones de contenedores con Docker Compose</h2>
Descubre cómo aprovechar las herramientas y conceptos de red de Docker para facilitar la comunicación entre contenedores y proporcionar servicios de red tanto a redes locales como externas. Explora los montajes y volúmenes del sistema de archivos para compartir datos sin problemas entre los contenedores y la máquina host. Además, adquiere dominio de Docker Compose para coordinar implementaciones de aplicaciones multicontener, lo que simplifica la configuración de herramientas complejas habituales en entornos de ingeniería y ciencia de datos.
<h2>Desarrollo e implementación proactivos</h2>
Este curso te proporciona las habilidades esenciales para mejorar tus procesos de desarrollo, pruebas y distribución. Aunque no es imprescindible, sacarás el máximo partido a este curso si has trabajado con contenedores sencillos y has creado algunos. Al finalizar el curso, tendrás los conocimientos y las herramientas necesarios para optimizar aplicaciones en contenedores, agilizar la comunicación entre contenedores e implementar aplicaciones multicontenedor con facilidad, lo que te permitirá avanzar en tu proceso de aprendizaje de Docker.

Introduction to Docker

Domina las compilaciones multi-etapa, herramientas de red de Docker y Docker Compose para apps óptimas.

Docker intermedio

Domina las compilaciones multietapa, las herramientas de red de Docker y Docker Compose para optimizar las aplicaciones en contenedores.

Exploración de imágenes de Docker

Docker intermedio

Ejercicio interactivo práctico