Cómo utilizar el complemento Docker para Visual Studio Code

Introducción

En este artículo, utilizaremos el complemento Docker para Visual Studio Code. Docker nos permite empaquetar nuestras aplicaciones en imágenes y ejecutarlas como contenedores en cualquier plataforma que tenga Docker instalado. Utilizaremos este complemento con dos stacks de desarrollador: Node.js y Go.

Instalación

Debe tener Docker instalado en su estación de trabajo. Las instrucciones sobre cómo instalar y ejecutar Docker están disponibles aquí y deben ser específicas para el sistema operativo en particular que esté ejecutando.

También es necesario tener instalado Visual Studio Code.

Una vez que haya instalado Visual Studio Code, ábralo, haga clic en la sección de extensiones en el panel más a la izquierda y busque Docker.

Una vez instalado, deberías notar algunas novedades en tu instancia de Visual Studio Code. En el panel más a la izquierda, hay una nueva sección de Docker con el logotipo de Docker, que al hacer clic en ella abre el explorador de Docker con tres secciones: imágenes, contenedores y registros.

También hay algunos comandos agregados a la paleta de comandos, que puedes ver abriendo la paleta de comandos y escribiendo docker.

Node.js

Utilizaremos una aplicación Node.js para demostrar las capacidades que el complemento Docker agrega a VSCode.

Vamos a crear un servidor Express.

mkdir docker-node
cd docker-node
npm init -y
npm install --save express
touch index.js

Deberíamos tener un árbol de directorios como este:

.├── index.js├── node_modules├── package-lock.json└── package.json1 directory, 3 files

Este es el contenido deindex.js

índice.js

const express = require('express')const app = express()app.listen(3000)app.get('/', (req, res) = {  res.send('hello world')})

Actualizar package.jsonpara tener un script de inicio.

paquete.json

"scripts": {    "start": "node index.js"  },

Ahora, podemos simplemente ejecutar esta aplicación con npm start, ir al puerto 3000y ver la aplicación funcionando.

Tradicionalmente, para agregar Docker, seguiríamos estos pasos.

1. Crear un Dockerfile (o docker-compose.yaml)
2. Agregue instrucciones de Docker al archivo (FROM, WORKDIR, ADD, EXPOSE, CMD)
3. Ejecutar docker build...en la terminal para construir la imagen.
4. Ejecutar docker run...en la terminal para ejecutar el contenedor

Sin embargo, con el complemento, todo lo que necesitamos hacer es lo siguiente. Abra la paleta de comandos y escriba docker, luego seleccione Docker: Add Docker files to Workspace. Debería ser la primera opción. Presione EnterSe le pedirá que elija la plataforma/pila, seleccione Node.js y presione Enter. Luego se le pedirá que elija un puerto. Escriba 3000ya que es el puerto al que escuchará nuestra aplicación. Los siguientes archivos se agregan a su espacio de trabajo: .dockerignore, docker-compose.debug.yml, docker-compose.yml, y Dockerfile.

Le .dockerignoredice a Docker que ignore los archivos enumerados al agregar archivos a la imagen de compilación.

Le permitirá docker-compose.debug.ymlejecutar docker-composecon inspección y adjuntar un depurador.

version: '2.1'services:  docker-node:    image: docker-node    build: .    environment:      NODE_ENV: development    ports:      - 3000:3000      - 9229:9229    command: node --inspect=0.0.0.0:9229 index.js

Sin embargo, si está depurando durante el desarrollo, es posible que necesite adjuntar un volumen para que los cambios que realice en su máquina local se mantengan en el contenedor.

El docker-compose.ymlarchivo es un archivo docker-compose estándar que se utiliza para ejecutar docker-services. Cuando agregue otros recursos o servicios, como conexiones de bases de datos y balanceadores de carga, deberá editar este archivo.

version: '2.1'services:  docker-node:    image: docker-node    build: .    environment:      NODE_ENV: production    ports:      - 3000:3000

El Dockerfile, que es el más importante aquí, ya que debe construirse, contiene las instrucciones que tendríamos que escribir manualmente si no tuviéramos el complemento instalado.

FROM node:8.9-alpineENV NODE_ENV productionWORKDIR /usr/src/appCOPY ["package.json", "package-lock.json*", "npm-shrinkwrap.json*", "./"]RUN npm install --production --silent  mv node_modules ../COPY . .EXPOSE 3000CMD npm start

A continuación, para crear la imagen, abra la paleta de comandos de VS Code, escriba y dockerluego seleccione Docker: Build Imagey presione Enter. Se le solicitará que seleccione el Dockerfile, selecciónelo y presione Enter. A continuación, se le solicitará que seleccione la etiqueta. Deje docker-nodeseleccionada la opción predeterminada y presione Enter. Se abrirá la Terminal integrada y se mostrarán los registros de compilación.

Finalmente, necesitamos ejecutar el contenedor. Una vez más, abra la paleta de comandos y escriba docker run, el select Docker: RunSe mostrará una lista de todos los contenedores en su sistema, seleccione docker-node:latest, el que etiquetamos y presione Enter. La terminal mostrará los registros del comando de ejecución. Observe que agregó la -p 3000:3000exposición del puerto a nuestra máquina host para que podamos ejecutar la aplicación visitando localhost:3000.

También podemos ejecutar el contenedor yendo al panel izquierdo, seleccionando la sección Docker , luego en Imágenes , elegimos la docker-nodeimagen, hacemos clic derecho y pulsamos en ejecutar. Los mismos logs se ejecutarán en la terminal.

También notarás que la sección de imágenes anterior tiene una lista de las imágenes en tu sistema. Una vez que el contenedor docker-node se esté ejecutando, podemos verificar los contenedores en ejecución en la misma sección e incluso detenerlos. Arriba, Attach Shellestá seleccionado, lo que es equivalente al comando docker que se muestra a continuación.

docker exec -it container sh

Esto muestra la salida del registro de terminal a continuación.

Puedes ver que estamos en el contenedor y podemos enumerar los archivos dentro del contenedor.

Detenga el contenedor e intente ejecutar la aplicación con docker-compose. Abra la paleta de comandos, busque docker-compose y vea el resultado.

Ir

Si no está familiarizado con Golang, puede pasar al siguiente tema.

Docker también está construido con Go

Vamos a crear una aplicación Go.

mkdir docker-go
cd docker-go
touch main.go

Su árbol de directorios tendrá un archivo.

.└── main.go0 directories, 1 file

Aquí está el contenido del main.goarchivo.

principal.go

package mainimport ("log""net/http")func helloHandler(w http.ResponseWriter, r *http.Request) {w.Write([]byte("Hello World"))}func main() {http.HandleFunc("/", helloHandler)if err := http.ListenAndServe(":9000", nil); err != nil {log.Fatalln("ListenAndServer Error", err)}}

Puedes ejecutar la aplicación con:

go run main.go

Sin embargo, usemos el complemento Docker de VSCode para crear una imagen y ejecutar el contenedor.

Cree el Dockerfile abriendo la paleta de comandos, escribiendo Docker y seleccionando Docker: Add Dockerfile to Workspace.

Se le pedirá que seleccione una plataforma, elija Goy presione Enter.

Luego se le pedirá que seleccione un puerto, escriba puerto 9000, ya que es el puerto que elegimos en nuestra aplicación, y presione Enter.

Se crearán los siguientes 4 archivos. .dockerignore, docker-compose.debug.yml, docker-compose.yml, y Dockerfile.

El .dockerignorearchivo le dice a Docker que ignore algunos archivos al agregar archivos a la imagen.

Docker Compose utiliza docker-compose.debug.ymly docker-compose.ymlpara ejecutar la aplicación. No son muy diferentes, ya que el archivo de depuración requiere una entrada adicional, ya que la depuración de Go es más compleja.

Sin embargo, lo más interesante es lo Dockerfilesiguiente: las dos últimas líneas build stageestán comentadas y añadidas.RUN go install -v ./...

# RUN go-wrapper download   # "go get -d -v ./..."# RUN go-wrapper install    # "go install -v ./..."RUN go install -v ./...

Aquí está el archivo Docker final.

#build stageFROM golang:alpine AS builderWORKDIR /go/src/appCOPY . .RUN apk add --no-cache git# RUN go-wrapper download   # "go get -d -v ./..."# RUN go-wrapper install    # "go install -v ./..."RUN go install -v ./...#final stageFROM alpine:latestRUN apk --no-cache add ca-certificatesCOPY --from=builder /go/bin/app /appENTRYPOINT ./appLABEL Name=docker-go Version=0.0.1EXPOSE 9000

Este tipo de patrón Dockerfile se denomina compilación en varias etapas y su principal ventaja es la optimización de las imágenes de Docker. Es útil principalmente para lenguajes compilados, que en la mayoría de los casos no requieren herramientas de compilación para ejecutar la aplicación compilada. Go es un buen ejemplo.

En pocas palabras, usamos parte de la compilación de Docker para compilar la aplicación, luego copiamos el binario compilado a una imagen de Docker más liviana y lo ejecutamos desde allí.

A continuación, debemos crear la imagen. Abra la paleta de comandos, escriba docker-build, seleccione Docker: Build Imagey presione Enter.

Se le pedirá que seleccione el Dockerfile, deje el valor predeterminado seleccionado y presione Enter.

Por último, se te pedirá que elijas una etiqueta de imagen. Deja la predeterminada docker-go:latesty presiona Enter. Verás los registros de compilación en la terminal integrada.

Por último, necesitamos ejecutar el contenedor. Abra la paleta de comandos y escriba docker run. Seleccione Docker: Runy presione Enter. Se le solicitará que seleccione la imagen. Seleccione docker-go:latest. Verá los registros en la Terminal integrada. Como antes, también puede ejecutar el contenedor seleccionando la sección Docker en el panel izquierdo y, en contenedores, seleccione docker-go, haga clic derecho en Ejecutar . Luego verá los mismos docker run registros.

Dado que nuestro contenedor Docker en ejecución solo tenía el binario, podemos adjuntar el shell en la sección de contenedores. Podemos escribir lsen el shell adjunto en la Terminal integrada y veremos un archivo binario llamado app, que corresponde al Dockerfile.

Otras características

Finalmente veremos otras características útiles que vienen con el complemento Docker de VSCode.

Inspeccionar imágenes de Docker: esto le permite inspeccionar las imágenes creadas y ver los detalles en un archivo JSON.

Seleccione la imagen que desee y abra el menú contextual y seleccione inspeccionar imagen . Se abrirá un archivo JSON con los detalles.

Mostrar registros de contenedores: esto también se encuentra en el menú contextual de los contenedores en ejecución. Usaremos el contenedor Node.js en ejecución. Los registros se mostrarán en la terminal integrada.

Registros: puedes iniciar sesión en tu registro de Docker y ver las imágenes que has creado y enviado.

Podar sistema: esta opción le permite ejecutar docker system prune, que borra las imágenes no utilizadas de su sistema. Está disponible a través del botón con las ventanas y una cruz en el explorador de Docker.

Intellisense: si tiene que escribir los archivos Docker (Dockerfile, docker-compose.yml) usted mismo, obtendrá una función de Intellisense muy útil al escribir. Incluso le proporcionará las etiquetas de imagen disponibles. Esto se activa al escribir el nombre de la imagen, luego dos puntos y CMD+ Space.

Linting de Dockerfile: cuando tienes un error en tus Dockerfiles, aparecerá una línea ondulada en VS Code y cuando pases el cursor sobre ella, se te mostrará cuál es el error.

La pestaña de problemas debajo de VS Code también lo mostrará.

Conclusión

El complemento Docker para VS Code puede ayudarte a configurar y crear rápidamente tus Dockerfiles, compilarlos y ejecutarlos, sin tener que escribir muchos de los comandos tú mismo.