Cómo se realiza la configuración en Docker y se implementa una aplicación

Hola, en este tutorial vamos a aprender cómo implementar una aplicación web golang con una ventana acoplable. Es posible que ya sepa que la ventana acoplable está completamente escrita en golang debido a su alto rendimiento y confiabilidad. Antes de profundizar en los detalles, asegúrese de haber instalado Docker y Golang y tener conocimientos básicos de ambos.

Acerca de Docker

Docker es un programa de código abierto que habilita una aplicación Linux empaquetada con dependencias completas y empaquetada como contenedor que comparte el mismo kernel del sistema operativo host. Por otro lado, el contenedor del sistema operativo de virtualización basado en hipervisores como VMware proporciona un alto nivel de aislamiento y seguridad, ya que la comunicación entre el huésped y el host se logra a través de hipervisores, ya que no comparten el espacio del kernel. Esto provocó una sobrecarga de rendimiento debido a la emulación de hardware. Así nació la virtualización de contenedores que garantiza un entorno virtual ligero que agrupa y aísla un conjunto de procesos y recursos del host y de otros contenedores. Por lo tanto, los procesos dentro del contenedor no pueden ver procesos o recursos fuera del contenedor.

Crear aplicaciones web «Hello World» en GO

Primero creemos un directorio para las aplicaciones GO que mostrará «Hello World en el navegador». Cree un directorio de aplicaciones web y conviértalo en el directorio actual. Navegue al directorio de la aplicación web y edite un archivo con el nombre «main.go»

root@demohost:~# mkdir web-app
root@demohost:~# cd web-app/
root@demohost:~/web-app# vim.tiny main.go

package main
import (
"fmt"
"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello %s", r.URL.Path[1:])
}

func main() {
http.HandleFunc("/World", handler)
http.ListenAndServe(":8080", nil)
}

Ejecute la aplicación GO «Hello World» anterior con el siguiente comando. Pruébelo apuntando su navegador favorito a http://127.0.0.1:8080/World. Verá el mensaje «Hello World» en el navegador.

root@demohost:~/web-app# PORT=8080 go run main.go

Nuestro siguiente paso es contener la aplicación anterior en una ventana acoplable. Por lo tanto, crearemos un dockerfile que le indicará a la ventana acoplable cómo contener nuestra aplicación web.

root@demohost:~/web-app# vim.tiny Dockerfile

# Get latest golang docker image.
FROM golang:latest

# Create a directory inside the container to store our web-app and then make it working directory.
RUN mkdir -p /go/src/web-app
WORKDIR /go/src/web-app

# Copy the web-app directory into the container.
COPY . /go/src/web-app

# Download and install third party dependencies into the container.
RUN go-wrapper download
RUN go-wrapper install

# Set the PORT environment variable
ENV PORT 8080

# Expose port 8080 to the host so that outer-world can access your application
EXPOSE 8080

# Tell Docker what command to run when the container starts
CMD ["go-wrapper", "run"]

Construir / ejecutar el contenedor

Cree su aplicación web GO con el siguiente comando. Recibirá confirmación después de una compilación exitosa.

root@demohost:~/web-app# docker build --rm -t web-app .
Sending build context to Docker daemon 3.584 kB
Step 1 : FROM golang:latest
latest: Pulling from library/golang
386a066cd84a: Already exists
75ea84187083: Pull complete
88b459c9f665: Pull complete
a31e17eb9485: Pull complete
1b272d7ab8a4: Pull complete
eca636a985c1: Pull complete
08158782d330: Pull complete
Digest: sha256:02718aef869a8b00d4a36883c82782b47fc01e774d0ac1afd434934d8ccfee8c
Status: Downloaded newer image for golang:latest
---> 9752d71739d2
Step 2 : RUN mkdir -p /go/src/web-app
---> Running in 9aef92fff9e8
---> 49936ff4f50c
Removing intermediate container 9aef92fff9e8
Step 3 : WORKDIR /go/src/web-app
---> Running in 58440a93534c
---> 0703574296dd
Removing intermediate container 58440a93534c
Step 4 : COPY . /go/src/web-app
---> 82be55bc8e9f
Removing intermediate container cae309ac7757
Step 5 : RUN go-wrapper download
---> Running in 6168e4e96ab1
+ exec go get -v -d
---> 59664b190fee
Removing intermediate container 6168e4e96ab1
Step 6 : RUN go-wrapper install
---> Running in e56f093b6f03
+ exec go install -v
web-app
---> 584cd410fdcd
Removing intermediate container e56f093b6f03
Step 7 : ENV PORT 8080
---> Running in 298e2a415819
---> c87fd2b43977
Removing intermediate container 298e2a415819
Step 8 : EXPOSE 8080
---> Running in 4f639a3790a7
---> 291167229d6f
Removing intermediate container 4f639a3790a7
Step 9 : CMD go-wrapper run
---> Running in 6cb6bc28e406
---> b32ca91bdfe0
Removing intermediate container 6cb6bc28e406
Successfully built b32ca91bdfe0

Es hora de ejecutar nuestra aplicación web GO. Para ello, ejecute el siguiente comando.

root@demohost:~/web-app# docker run -p 8080:8080 --name="test" -d web-app
7644606b9af28a3ef1befd926f216f3058f500ffad44522c1d4756c576cfa85b

Vea sus aplicaciones web en http: // localhost: 8080 / World. Ha colocado en contenedor una aplicación web Go que es repetible / determinista. Utilice los siguientes comandos para iniciar, detener y verificar el estado del contenedor.

List all containers
root@demohost:~/ docker ps -a

Start the container using it's id
root@demohost:~/ docker start CONTAINER_ID_OF_WEB_APP

Stop the container using it's id
root@demohost:~/ docker stop CONTAINER_ID_OF_WEB_APP

Reconstruir la imagen de la ventana acoplable

Supongamos que está desarrollando una aplicación web y cambiando los códigos. Ahora, para ver el resultado después de actualizar los códigos, debe reconstruir la imagen de la ventana acoplable, detener la imagen anterior y ejecutar la nueva, y esto continúa cada vez que cambia el código. Para que este proceso sea automático, usaremos volúmenes de la ventana acoplable para compartir un directorio entre el host y el contenedor. Lo que significa que no es necesario reconstruir imágenes para realizar cambios dentro del contenedor. Ahora, ¿cómo detectará el contenedor si ha realizado cambios en el código fuente de sus aplicaciones web? La respuesta es que hay una buena herramienta llamada «Gin». https://github.com/codegangsta/gin que detecta si ha realizado algún cambio en el código fuente, reconstruye la imagen / binario y ejecuta los procesos dentro del contenedor con nuevos códigos actualizados.

Para que este proceso sea automático, editaremos el Dockerfile e instalaremos Gin y lo ejecutaremos como comando de entrada. Expondremos el puerto 3030 (proxy Gin) en lugar de 8080. El proxy Gin reenviará el tráfico al puerto 8080 de las aplicaciones web.

root@demohost:~/web-app# vim.tiny Dockerfile

# Get latest golang docker image.
FROM golang:latest

# Create a directory inside the container to store our web-app and then make it working directory.
RUN mkdir -p /go/src/web-app
WORKDIR /go/src/web-app

# Copy the web-app directory into the container.
COPY . /go/src/web-app

# Download and install third party dependencies into the container.
RUN go get github.com/codegangsta/gin
RUN go-wrapper download
RUN go-wrapper install

# Set the PORT environment variable
ENV PORT 8080

# Expose port 8080 to the host so that outer-world can access your application
EXPOSE 3030

# Run Gin when the container starts
CMD gin run

# Tell Docker what command to run when the container starts
CMD ["go-wrapper", "run"]

Ahora construye la imagen e inicia el contenedor.

root@demohost:~/web-app# docker build --rm -t web-app .

Ejecutaremos la ventana acoplable con el directorio de trabajo actual como raíz del directorio de la aplicación web y enlazaremos CWD al directorio de la aplicación en el contenedor exponiendo el puerto no 3030

root@demohost:~/web-app# docker run -p 3030:3030 -v `pwd`:/go/src/web-app --name="test" -d web-app

Apunte su navegador a http: // localhost: 3030 / World, podrá ver sus aplicaciones web. Ahora, si cambia algo en el código, se reflejará en el navegador una vez que actualice el navegador.

Conclusión

Y eso es todo, nuestra aplicación web Go se ejecuta en el contenedor Docker de Ubuntu 16.04. Puede ampliar las aplicaciones web actuales utilizando un marco GO para un desarrollo rápido para desarrollar API, aplicaciones web y servicios de back-end rápidamente.