Introducción
En este laboratorio, aprenderá cómo contenerizar una aplicación de Go utilizando el comando docker init. El laboratorio comienza verificando la correcta instalación de Docker Desktop en la máquina virtual (VM) de LabEx, incluyendo la comprobación de la versión de Docker y la ejecución del contenedor hello-world para asegurarse de que Docker funcione como se espera.
Los pasos subsiguientes implican inicializar un proyecto de Go con docker init, personalizar el archivo Dockerfile y el archivo Compose generados específicamente para una aplicación de Go, y finalmente, construir y ejecutar la aplicación de Go utilizando Docker Compose. Esta experiencia práctica le proporcionará las habilidades necesarias para contenerizar eficazmente aplicaciones de Go utilizando las herramientas modernas de Docker.
Instalar Docker Desktop y verificar Docker Init
En este paso, verificaremos que Docker esté instalado correctamente en la máquina virtual (VM) de LabEx. La VM de LabEx viene preinstalada con Docker Engine, por lo que verificaremos la versión de Docker y ejecutaremos un simple contenedor "hello-world" para asegurarnos de que todo funcione como se espera.
Primero, veamos cómo comprobar la versión de Docker. Abra una terminal en la VM de LabEx. Puede encontrar el icono de la terminal en el escritorio o en el menú de aplicaciones.
Ejecute el siguiente comando en la terminal:
docker --version
Este comando mostrará la versión de Docker instalada en el sistema. Debería ver una salida similar a:
Docker version 20.10.21, build xxxxxxx
Si ve la versión de Docker, significa que Docker está instalado correctamente. Si encuentra un error, póngase en contacto con el soporte.
A continuación, ejecutemos el contenedor "hello-world". Este es un contenedor simple que imprime un mensaje en la consola y luego se cierra.
Ejecute el siguiente comando en la terminal:
docker run hello-world
Antes de ejecutar el comando, debe descargar la imagen hello-world de Docker Hub. Docker Hub es un registro público de imágenes de Docker.
Ejecute el siguiente comando para descargar la imagen:
docker pull hello-world
Este comando descarga la imagen hello-world de Docker Hub a su máquina local. Debería ver una salida similar a:
Using default tag: latest
latest: Pulling from library/hello-world
...
Digest: sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Status: Downloaded newer image for hello-world:latest
docker.io/library/hello-world:latest
Ahora, ejecute el comando docker run hello-world de nuevo:
docker run hello-world
Este comando ejecutará el contenedor hello-world. Debería ver una salida similar a:
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/get-started/
Este mensaje indica que Docker está funcionando correctamente y que ha ejecutado con éxito su primer contenedor.
Inicializar un proyecto de Go con Docker Init
En este paso, inicializaremos un nuevo proyecto de Go y usaremos docker init para generar los archivos Dockerfile y docker-compose.yml necesarios. Esto proporcionará un punto de partida para contenerizar nuestra aplicación de Go.
Primero, creemos un nuevo directorio para nuestro proyecto de Go. Abra una terminal en la máquina virtual (VM) de LabEx y ejecute los siguientes comandos:
mkdir my-go-app
cd my-go-app
Estos comandos crean un nuevo directorio llamado my-go-app en el directorio ~/project y luego cambian el directorio actual a my-go-app.
A continuación, necesitamos inicializar un módulo de Go. Esto creará un archivo go.mod que realiza un seguimiento de las dependencias de nuestro proyecto.
Ejecute el siguiente comando en la terminal:
go mod init my-go-app
Este comando inicializa un nuevo módulo de Go llamado my-go-app. Debería ver una salida similar a:
go: creating new go.mod: module my-go-app
go: to add module requirements and sums:
go mod tidy
Ahora, creemos una simple aplicación de Go. Cree un nuevo archivo llamado main.go en el directorio my-go-app utilizando el editor nano:
nano main.go
Agregue el siguiente código al archivo main.go:
package main
import "fmt"
func main() {
fmt.Println("Hello, Docker!")
}
Este es un simple programa de Go que imprime "Hello, Docker!" en la consola.
Guarde el archivo y salga del editor nano presionando Ctrl+X, luego Y y luego Enter.
Ahora, usaremos docker init para generar los archivos Dockerfile y docker-compose.yml. Sin embargo, la VM de LabEx no tiene Docker Compose instalado por defecto. Primero debemos instalarlo.
Descargue la última versión de Docker Compose utilizando curl:
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
Haga que el binario de Docker Compose sea ejecutable:
sudo chmod +x /usr/local/bin/docker-compose
Verifique la instalación comprobando la versión de Docker Compose:
docker-compose --version
Debería ver una salida similar a:
docker-compose version 1.29.2, build xxxxxxx
Ahora que Docker Compose está instalado, podemos continuar con docker init.
Ejecute el siguiente comando en la terminal:
docker init
docker init hará una serie de preguntas para configurar los archivos Dockerfile y docker-compose.yml. Aquí están las respuestas recomendadas para este laboratorio:
- ¿Cómo desea llamar a esta aplicación?
my-go-app - ¿En qué puerto está escuchando esta aplicación?
3000(Este es un marcador de posición, en este simple ejemplo no usaremos realmente un puerto) - ¿Cuál es el archivo principal a ejecutar?
main.go - ¿Desea incluir la configuración de Docker Compose?
Yes - Por favor, elija una versión de Docker Compose:
2.0
Después de responder estas preguntas, docker init generará un archivo Dockerfile y un archivo docker-compose.yml en el directorio my-go-app.
Puede ver el contenido de los archivos generados utilizando el comando cat:
cat Dockerfile
cat docker-compose.yml
Estos archivos proporcionan una configuración básica para construir y ejecutar nuestra aplicación de Go en un contenedor de Docker. En el siguiente paso, personalizaremos estos archivos para adaptarlos mejor a nuestras necesidades.
Personalizar el Dockerfile y el archivo Compose generados para Go
En este paso, personalizaremos los archivos Dockerfile y docker-compose.yml generados en el paso anterior. Optimizaremos el Dockerfile para construir nuestra aplicación de Go y configuraremos el archivo docker-compose.yml para ejecutar nuestra aplicación.
Primero, examinemos el Dockerfile generado. Abra el Dockerfile en el directorio my-go-app utilizando el editor nano:
nano Dockerfile
El Dockerfile generado podría verse algo así:
## syntax=docker/dockerfile:1
FROM golang:latest AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download && go mod verify
COPY . .
RUN go build -o my-go-app
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/my-go-app .
EXPOSE 3000
CMD ["./my-go-app"]
Este Dockerfile utiliza una construcción de múltiples etapas. La primera etapa (builder) utiliza la imagen golang:latest para construir la aplicación de Go. La segunda etapa utiliza la imagen alpine:latest para ejecutar la aplicación.
Modifiquemos el Dockerfile para utilizar una versión específica de Go y optimizar el proceso de construcción. Reemplace el contenido del Dockerfile con lo siguiente:
## syntax=docker/dockerfile:1
FROM golang:1.17 AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download && go mod verify
COPY . .
RUN go build -o my-go-app
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/my-go-app .
CMD ["./my-go-app"]
Hemos cambiado la imagen base para la etapa de construcción a golang:1.17. Esto asegura que estemos utilizando una versión específica de Go para construir nuestra aplicación.
Guarde el archivo y salga del editor nano.
Ahora, examinemos el archivo docker-compose.yml generado. Abra el archivo docker-compose.yml en el directorio my-go-app utilizando el editor nano:
nano docker-compose.yml
El archivo docker-compose.yml generado podría verse algo así:
version: "3.9"
services:
my-go-app:
build: .
ports:
- "3000:3000"
Este archivo docker-compose.yml define un solo servicio llamado my-go-app. Especifica que el servicio debe construirse desde el directorio actual (.) y que el puerto 3000 debe exponerse.
Dado que nuestra aplicación en realidad no escucha en un puerto, podemos eliminar la sección ports. Modifique el archivo docker-compose.yml para que quede así:
version: "3.9"
services:
my-go-app:
build: .
Guarde el archivo y salga del editor nano.
En este paso, hemos personalizado los archivos Dockerfile y docker-compose.yml para adaptarlos mejor a nuestras necesidades. En el siguiente paso, construiremos y ejecutaremos nuestra aplicación de Go utilizando Docker Compose.
Compilar y ejecutar la aplicación de Go con Docker Compose
En este paso, construiremos y ejecutaremos nuestra aplicación de Go utilizando Docker Compose. Docker Compose simplifica el proceso de construcción y ejecución de aplicaciones de múltiples contenedores. En nuestro caso, solo tenemos un contenedor, pero Docker Compose sigue proporcionando una forma conveniente de gestionar el proceso de construcción y ejecución.
Primero, navegue al directorio my-go-app en la terminal:
cd ~/project/my-go-app
Para construir la imagen de Docker para nuestra aplicación, ejecute el siguiente comando:
docker-compose build
Este comando construirá la imagen de Docker basada en el Dockerfile en el directorio actual. Debería ver una salida similar a:
Building my-go-app
Sending build context to Docker daemon 3.072kB
Step 1/6 : FROM golang:1.17 AS builder
---> xxxxxxxxxxxxxxxx
Step 2/6 : WORKDIR /app
---> Using cache
---> xxxxxxxxxxxxxxxx
Step 3/6 : COPY go.mod go.sum ./
---> Using cache
---> xxxxxxxxxxxxxxxx
Step 4/6 : RUN go mod download && go mod verify
---> Using cache
---> xxxxxxxxxxxxxxxx
Step 5/6 : COPY . .
---> xxxxxxxxxxxxxxxx
Step 6/6 : RUN go build -o my-go-app
---> Running in xxxxxxxxxx
Removing intermediate container xxxxxxxxxx
---> xxxxxxxxxxxxxxxx
Successfully built xxxxxxxxxxxxxxxx
Successfully tagged my-go-app_my-go-app:latest
Esta salida indica que la imagen de Docker se ha construido con éxito.
Ahora, para ejecutar la aplicación, ejecute el siguiente comando:
docker-compose up
Este comando iniciará el contenedor definido en el archivo docker-compose.yml. Debería ver una salida similar a:
Starting my-go-app_my-go-app_1 ... done
Attaching to my-go-app_my-go-app_1
my-go-app_1 | Hello, Docker!
my-go-app_my-go-app_1 exited with code 0
Esta salida muestra que nuestra aplicación de Go se ha ejecutado y ha impreso "Hello, Docker!" en la consola. Luego, el contenedor salió con código 0, lo que indica una ejecución exitosa.
Para detener el contenedor, presione Ctrl+C en la terminal.
También puede ejecutar el contenedor en modo desatendido agregando la bandera -d al comando docker-compose up:
docker-compose up -d
Esto iniciará el contenedor en segundo plano. Para ver los registros del contenedor, ejecute el siguiente comando:
docker logs my-go-app_my-go-app_1
Para detener el contenedor que se está ejecutando en modo desatendido, ejecute el siguiente comando:
docker-compose down
Este comando detendrá y eliminará el contenedor.
En este paso, hemos construido y ejecutado con éxito nuestra aplicación de Go utilizando Docker Compose. Esto demuestra cómo Docker Compose puede simplificar el proceso de gestión de aplicaciones contenerizadas.
Resumen
En este laboratorio, comenzamos verificando la instalación exitosa de Docker Desktop en la máquina virtual (VM) de LabEx. Esto implicó comprobar la versión de Docker utilizando el comando docker --version y confirmar su correcta instalación. Luego, procedimos a descargar la imagen hello-world desde Docker Hub utilizando docker pull hello-world y, posteriormente, ejecutamos el contenedor con docker run hello-world para asegurarnos de que Docker estaba funcionando como se esperaba, imprimiendo un mensaje de confirmación en la consola.
Este primer paso estableció un entorno de Docker funcional, sentando las bases para los pasos posteriores que involucran el uso de docker init para contenerizar una aplicación de Go.
