¡Heyyyy! De nuevo yo con un post sobre un tema apasionante: ¡Los contenedores!. Quisiera responder de inmediato la pregunta del post ¿De verdad necesitamos saber de contenedores? y la respuesta es sencilla:
Claro que Si
¿Porque razón digo esto?:
- Porque muchas empresas están empezando a solicitarlo hoy ya que mejora enormemente el proceso de desarrollo
- La curva de aprendizaje no es muy grande. Con solo unos cuantos videos en internet ya sabras mas o menos de que trata.
- La industria cada vez necesita aplicaciones mas rapidas, livianas, fiables y altamente escalables. Los contenedores logran esto.
¿Que es Docker?
Docker es una plataforma opensource que te permite desarrollar, enviar y ejecutar aplicaciones. Docker nos permite tratar las aplicaciones como infraestructura y hacer una separación lógica entre la infraestructura y la aplicación. Con Docker se envía más rapido, se implementa más rapido y se ejecuta más rapido. Podemos crear flujos de trabajo basado en imagenes para el lanzamiento de nuevos releases o cambios en el código o la implementación de una aplicación.
Pero bueno, esto parace sacado de algo de Wikipedia. Yo quiero compartirles mi definición personal. Para mi docker es la forma en que virtualizo la aplicación dentro de mi sistema operativo. Si has trabajado con Vmware, hyper-v o cualquier otro virtualizador seguramente entiendes que estas virtualizando el Sistema operativo y dentro de ese S.O implementas tus aplicaciones. Ahora con Docker imagínate que estás virtualizando la aplicación dentro de tu sistema operativo. Es decir, dentro de tu host vas a meter una plataforma, en este caso Docker, para virtualizar cualquier aplicación, Ejemplo: apache, node-js,nginx,mysql,etc. y todo corriendo sobre el mismo host.
Implementando contenedores en Google Cloud
En este post no voy a explicar como instalar docker, realmente es muy sencillo y hay muchos sitios en internet que te enseñan a hacerlo. Simplemente con la siguiente linea en linux podras instalarlo
curl -sSL https://get.docker.com/ | sh
Podemos comprobar que está instalado ejecutando
Docker run hello-world
Ahora nos logueamos en nuestro proyecto de Google cloud porque vamos a utilizar algunos servicios de alli. recuerden que para loguearse desde la shell en GCP necesitan el Cloud SDK instalado y ejecutar:
gcloud init
El asistente te irá preguntando con que cuenta te vas a loguear y la zona predeterminada para trabajar.Si ya tienes una cuenta pues te preguntara si quiere re-inicializarla nuevamente con las configuraciones por defecto.
Construyendo la imagen
Vamos a simular que nos han entregado una aplicacion en node-js. Simplemente es un servidor corriendo node y que nos devuelve un mensaje de texto. Vamos a crear una carpeta que la llamaremos docker-gcp y dentro de ella vamos a configurar nuestro Dockerfile con el codigo que nos dan de la aplicacion. Primero lo probamos en nuestro pc y luego lo enviamos al registry de Google Cloud ( Ahora les explico que es).
1- Creamos la carpeta e ingresamos a ella
mkdir docker-gcp ; cd docker-gcp
2- Creamos el archivo Dockerfile ( el dockerfile es el archivo que tiene la configuración del despliegue de la aplicación que vamos a implementar)
cat > Dockerfile <<EOF
# Descarga la imagen del runtime de node
FROM node:lts
# configura el directorio de trabajo /app
WORKDIR /app
# Copia el contenido de la carpeta actual en /app
ADD . /app
# Hace que el puerto 80 este expuesto al mundo
EXPOSE 80
# Ejecuta app.js usando node cuando lanzamos el contenedor
CMD ["node", "app.js"]
EOF
Si despues de ver el anterior código estás diciendo:
¿Que rayos es eso?
no te preocupes vamos a explicar cada linea
- From node:lts = Esta linea significa que Docker se conectará al registry publico docker-hub y descargará la imagen de node version long term support (lts)
- Workdir /app = Crea el directorio /app dentro del contenedor. Alli es donde le vamos a pasar los archivos para que la aplicación se ejecute.
- ADD . /app = Le estamos diciendo con el «.» que copie todo lo que hay en nuestro directorio actual al directorio dentro del contenedor /app.
- Expose 80 = Ahora exponemos el puerto 80 para que acepte solicitudes. Pero ¡Ojo! Todavia no significa que estaria accesible, luego tendremos que hacer mapeo desde el host.
- CMD [«node», «app.js»] = Finalmente ejecutamos node para iniciar la aplicación
3- Creamos el archivo que contiene la aplicación
cat > app.js <<EOF
const http = require('http');
const hostname = '0.0.0.0';
const port = 80;
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('El Blog de Jukajo\n');
});
server.listen(port, hostname, () => {
console.log('Server running at http://%s:%s/', hostname, port);
});
process.on('SIGINT', function() {
console.log('Caught interrupt signal and will exit');
process.exit();
});
EOF
Este archivo es un simple servidor HTTP que responde con el texto «El blog de jukajo»
La carpeta debe quedar asi
4- Construir la imagen con docker build
docker build -t my-app-node:1.0 .
Docker build es el comando que usamos para contruir la imagen basado en el archivo dockerfile y en el codigo de la aplicación. La Flag -t indica el nombre de la imagen y el tag para ponerle una version a nuestra imagen. Siempre es bueno ponerle el tag porque si no despues va a tomar siempre la ultima version de nuestra imagen y nos podemos liar con cambios que vamos haciendo al código o al archivo docker file.
¡Ojo! No olvidar el «.» al final que se refier al directorio actual en el que estamos trabajando. Despues de presionar enter deberían ver una imagen asi:
5- Validamos la imágen con
docker images
Deberian ver la imágen asi
6- Probamos el contenedor en local
docker run -p 8080:80 --name my-app my-node-app:1.0
con la flag -p Mapeamos el puerto para que sea accesible desde nuestro host y la flag –name nos permite ponerle un nombre al contenedor, en este caso my-app. Porque yo puedo ejecutar el mismo contenedor varias veces con diferente nombre y en diferentes puertos sobre el mismo host. !Awesome!
Tendrás que ver una imágen como la siguiente
6- Probamos el Acceso con curl
Abrimos otra terminal y probamos el acceso con curl. Puedes abrir el navegador y ejecutarlo alli directamente
curl http://localhost:8080
7- Subimos nuestra imagen al registry de Google
En Google Cloud contamos con un servicio llamado Container registry. Este servicio nos permite tener en nuestro cloud como un dockerhub privado para nuestra imagenes. Muchas empresas lo usan cuando sus desarrolladores o sysadmins necesitan un espacio para almacenar imagenes de contenedores. Y para subir las imagenes a nuestro registry, basicamente necesitamos lo siguiente:
- [hostname]= gcr.io
- [project-id]= Nuestro ID de proyecto
- [image]= el nombre de nuestra imagen
- [tag]= un tag (1.0) si no le ponemos aparecera latest
Entonces empecemos con sacar el Id de nuestro proyecto con la siguiente linea
gcloud config list project
Esto nos mostrará el ID de nuestro proyecto, como muestra la siguiente imágen
Conociendo nuestro ID tenemos que taguear la imágen para luego subirla al registry con el siguiente comando
docker tag my-node-app:2.0 gcr.io/[project-id]/my-node-app:2.0
Con esto ya lo veremos en nuestra lista de imágenes con docker images
Habilitamos la API de container Registry con:
gcloud services enable containerregistry.googleapis.com
Tenemos que crear una cuenta de servicio que tenga los siguientes roles habilitados para que pueda escribir y leer en cloud storage y a la misma vez hacer push (enviar las imagenes) a nuestro registry en Google cloud.
- Storage Object Viewer (roles/storage.objectViewer)
- Storage Legacy Bucket Writer (roles/storage.legacyBucketWriter)
- Storage Admin (roles/storage.admin)
Crear y administrar cuentas de servicio
A continuación pasamos a autorizar la cuenta de servicio
gcloud auth activate-service-account test-gcp@test-jukajo.iam.gserviceaccount.com --key-file=jukajo-file.json
La linea anterior activa la cuenta de servicio [email protected] usando un archivo de autenticación en formato json. Este archivo lo pueden crear cuando crean la cuenta de servicio y generan la clave para la cuenta de servicio. Esto es muy útil en temas de serguridad a la hora de usar Cuentas de servicio con desarrolladores.
El siguiente paso es autoirizar la cuenta de docker con la cuenta de servicio anteriormente creada.
gcloud auth configure-docker
Y ahora si, sin mas preambulos hacemos el push de nuestra imagen de Docker a container registry
docker push gcr.io/test-jukajo/my-node-app:2.0
Podemos validar que la imágen ha sido creada en nuestra consola de GCP, como muestra el siguiente screenshot
Ahora que podemos hacer con esta Imágen:
- Implementarla en cloud Run
- Deployarla en un cluster de kubernetes
- Agregar imagenes con codigo nuevo o cambios en nuestro Registry
Bueno amigos, eso era todo por hoy, realmente hay mucho que decir y hacer con este tema pero un solo post no da para tanto. Aprendan de contenedores. ¡Es muy muy interesante!
Y si sientes que necesitas ayuda con un problemilla en Google cloud simplemente contacteme por linkedin o deja un comentario. Estoy muy abierto a aportar lo que mas pueda en el mundo de tecnologia.
Si te gusto el articulo, compartelo. Aprecio mucho que me apoyen con una recomendación en sus redes sociales.
See you in the Cloud
Leave a Comment