DEV Community: crisemcon

Guía Practica de Contenedores: Administrando nuestra aplicación con Kubernetes (3/3)

crisemcon — Mon, 04 Oct 2021 22:16:56 +0000

(Esta es la ultima parte de una guía practica sobre contenedores que abarca el desarrollo de un API CRUD, el uso de Docker para la contenerizacion de la aplicación, la incorporación de Docker Compose para la sincronización de múltiples contenedores, y finalmente Kubernetes para la orquestación de los contenedores que conforman la aplicación que desarrollaremos.) Codigo Fuente

En esta guía, migraremos nuestra API multicontenedor de manejo de estudiantes de Docker Compose, que usaba Node.js, MySQL y PhpMyAdmin, a una arquitectura de Kubernetes, la cual es visualizada en el siguiente diagrama:

1) Requisitos

Primero instalaremos las tecnologías necesarias para el desarrollo de esta guia: Kubectl y Minikube.
Si ya posees las tecnologias mencionadas anteriormente y las de la primera y segunda parte de la guia, puedes saltarte a la seccion 2

1.1) Instalando Kubectl

Necesitamos una herramienta de línea de comandos para interactuar y ejecutar comandos en clústeres de Kubernetes. Kubectl se utiliza para implementar aplicaciones, inspeccionar y administrar los recursos del clúster.
Entonces, descargamos la última versión de lanzamiento de kubectl con el comando:

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Luego instalamos kubectl:

sudo install -o root -g root -m 0755 kubectl / usr / local / bin / kubectl

Finalmente comprobamos que la instalacion fue exitosa imprimiendo la versión de kubectl en el sistema:

kubectl version --client

Mas detalles acerca de este paso en: https://kubernetes.io/es/docs/tasks/tools/install-kubectl/

1.2) Instalando Minikube

Ahora necesitamos un entorno de Kubernetes local. Como requisito debemos tener un administrador de contenedores o máquinas virtuales para este paso.
Actualmente tenemos Docker, que es un administrador de contenedores, por lo que podemos continuar con la instalación de minikube:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb
sudo dpkg -i minikube_latest_amd64.deb

Luego podemos iniciar nuestro clúster con el comando:

minikube start

Si todo está correcto, nuestro clúster de Kubernetes se habilitará y deberíamos ver algo como esto:

Mas detalles acerca este paso en: https://minikube.sigs.k8s.io/docs/start/

Es posible que este comando no funcione y arroje un error como este: "Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Get http://%2Fvar%2Frun%2Fdocker.sock/v1.39/containers/json: dial unix /var/run/docker.sock: connect: permission denied”. Esto se debe a que necesitamos privilegios sudo para ejecutar el comando Docker. Incluso si ejecutamos sudo minikube start, no lo aceptará porque no es seguro ejecutarlo en modo sudo. Para resolver este problema, debemos agregar nuestra cuenta de usuario al grupo de Docker:

sudo groupadd docker
sudo usermod -aG docker $USER
newgrp docker

Mas detalles acerca de este error en: https://linuxhandbook.com/docker-permission-denied/

2) Descripción general de los componentes de Kubernetes para nuestro sistema

Estos son los componentes que vamos a implementar para nuestro sistema de gestión de estudiantes.
Para comprender este diagrama, debemos aprender los conceptos principales de Kubernetes:

Node: un nodo puede ser una máquina virtual o física, según el clúster. Cada nodo contiene los servicios necesarios para ejecutar Pods, administrados por el plano de control.
Pod: la unidad básica de trabajo. Los pods son las unidades de computación implementables más pequeñas que se pueden crear y administrar en Kubernetes. Los pods casi nunca se crean por sí mismos, sino que los controladores de pods hacen todo el trabajo real.
Service: una forma abstracta de exponer una aplicación que se ejecuta en un conjunto de Pods como un servicio de red.
Deployment: forma más común de obtener su aplicación en Kubernetes. Crea un ReplicaSet (que crea un conjunto estable de pods) para cada especificación de implementación.
Secret: le permiten almacenar y administrar información confidencial, como contraseñas, tokens OAuth y claves ssh.
Volume: es esencialmente un directorio accesible para todos los contenedores que se ejecutan en un pod. A diferencia del sistema de archivos local del contenedor, los datos en volúmenes se conservan durante los reinicios del contenedor.
Persistent Volume (PV): es un recurso de todo el clúster que puede usar para almacenar datos de manera que persistan más allá de la vida útil de un pod. El PV no está respaldado por un almacenamiento conectado localmente en un nodo trabajador, sino por un sistema de almacenamiento en red.
Persistent Volume Claim (PVC): es la solicitud para suministrar almacenamiento persistente con un tipo y configuración específicos.

Para obtener más información, lea la documentación de Conceptos de Kubernetes: https://kubernetes.io/docs/concepts/

3) Componente Secret

Primero, vamos a construir nuestro componente secreto, que contendrá nuestros datos privados como la contraseña de root de MySQL, el usuario de MySQL, la contraseña del usuario de MySQL y el nombre de la base de datos de MySQL.

touch sm-mysql-secret.yaml

Antes de comenzar a escribir en el archivo, debemos recordar que el componente secreto requiere que los valores proporcionados estén codificados en base64. Entonces, necesitamos codificar nuestros datos privados de la siguiente manera:

Ahora podemos escribir las credenciales en nuestro archivo:

apiVersion: v1
kind: Secret
metadata:
        name: sm-mysql-secret
type: Opaque
data:
        sm-mysql-root-pass: cm9vdA==
        sm-mysql-smuser: c211c2Vy
        sm-mysql-smpass: c21wYXNz
        sm-mysql-db: c3R1ZGVudG1hbmFnZW1lbnRkYg==

Luego necesitamos ejecutar este archivo con kubectl, para generar nuestro componente:

kubectl apply -f sm-mysql-secret.yaml

4) Componentes MySQL

A continuacion implementaremos los componentes de Kubernetes relativos a la base de datos MySQL.

4.1) Persistent Volume and Persistent Volume Claim

Primero, debemos configurar los componentes de reclamo de Volumen persistente y Volumen persistente. Esto se puede hacer en el mismo archivo separando ambos con “---”.

touch sm-mysql-pv.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
 name: sm-mysql-pv-volume
 labels:
        type: local
spec:
 storageClassName: manual
 capacity:
        storage: 1Gi
 accessModes:
        - ReadWriteOnce
 hostPath:
        path: "/mnt/data"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: sm-mysql-pv-claim
spec:
 storageClassName: manual
 accessModes:
        - ReadWriteOnce
 resources:
        requests:
         storage: 1Gi

Luego necesitamos ejecutar este archivo con kubectl, para generar nuestros componentes:

kubectl apply -f sm-mysql-pv.yaml

Hemos configurado el Volumen, que tiene 1 Gb de capacidad de almacenamiento y está guardando los datos localmente en el Clúster de Minikube.

Lo podemos ver en la terminal con los comandos:

minikube ssh
cd ../..
cd mnt/data/

4.2) Deployment

Ahora tenemos que configurar el componente Deployment. Esto creará un pod que ejecutará un contenedor con una imagen de MySQL 5.7.
Vamos a utilizar las credenciales almacenadas en nuestro componente Secreto y tenemos que exponer manualmente el puerto "3306", que por defecto está expuesto por el contenedor, pero el pod tiene que conocer esta información. Además, vamos a vincular nuestro Volumen Persistente y reclamarlo con el PVC.

touch sm-mysql-deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: sm-mysql
spec:
 selector:
        matchLabels:
         app: sm-mysql
 strategy:
        type: Recreate
 template:
        metadata:
         labels:
           app: sm-mysql
        spec:
         containers:
         - image: mysql:5.7
           name: sm-mysql
           env:
           - name: MYSQL_ROOT_PASSWORD
             valueFrom:
               secretKeyRef:
                 name: sm-mysql-secret
                 key: sm-mysql-root-pass
           - name: MYSQL_USER
             valueFrom:
               secretKeyRef:
                 name: sm-mysql-secret
                 key: sm-mysql-smuser
           - name: MYSQL_PASSWORD
             valueFrom:
               secretKeyRef:
                 name: sm-mysql-secret
                 key: sm-mysql-smpass
           - name: MYSQL_DATABASE
             valueFrom:
               secretKeyRef:
                 name: sm-mysql-secret
                 key: sm-mysql-db
           ports:
           - containerPort: 3306
             name: sm-mysql
           volumeMounts:
           - name: sm-mysql-persistent-storage
             mountPath: /var/lib/mysql
         volumes:
         - name: sm-mysql-persistent-storage
           persistentVolumeClaim:
             claimName: sm-mysql-pv-claim

Luego necesitamos ejecutar este archivo con kubectl, para generar nuestro componente:

kubectl apply -f sm-mysql-deploy.yaml

Nota: El uso del componente Deployment para una base de datos no es escalable, porque la implementación es stateless y una base de datos es un componente stateful. Si queremos tener una base de datos escalable, necesitaremos implementar un StatefulSet en lugar de una implementación, lo que requiere un trabajo adicional para replicar con éxito los pods.

4.3) Service

Necesitamos configurar nuestro servicio MySQL interno, que permitirá la posibilidad de interactuar con otros pods dentro de nuestro clúster.

touch sm-mysql-service.yaml

apiVersion: v1
kind: Service
metadata:
 name: sm-mysql
spec:
 ports:
 - protocol: TCP
        port: 3306
        targetPort: 3306
 selector:
        app: sm-mysql

Entonces necesitamos ejecutar este archivo con kubectl, para generar nuestro componente:

kubectl apply -f sm-mysql-deploy.yaml

4.4) Test

Podemos ver si nuestros componentes se crearon correctamente y se están ejecutando actualmente:

kubectl get secrets

kubectl get deployments

kubectl get services

kubectl get pods

Podemos entrar a la terminal del Pod:

kubectl exec -it sm-mysql-57fbb49dd-47pvf /bin/bash

Ahora que estamos dentro, podemos ejecutar el comando mysql para ingresar al proceso de la base de datos:

mysql -u root -p root

Ingresamos la contraseña del root que es: "root" y una vez dentro, podemos obtener las bases de datos con la siguiente consulta SQL:

SHOW DATABASES;

Con esto corroboramos que nuestra base de datos studentmanagementdb se creó correctamente.

5) Componentes PhpMyAdmin

A continuacion implementaremos los componentes de Kubernetes relativos al administrador de base de datos PhpMyAdmin.

5.1) Deployment

Tenemos que configurar el componente Deployment. Esto creará un pod que ejecutará un contenedor con una imagen phpmyadmin de DockerHub.
Vamos a exponer el puerto “80” y usar las mismas credenciales para autenticarnos en nuestro servicio MySQL. Además, vamos a conectar esta Deployment al servicio MySQL llamado "sm-mysql".

touch sm-phpmyadmin-deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: sm-phpmyadmin
 labels:
        app: sm-phpmyadmin
spec:
 replicas: 1
 selector:
        matchLabels:
         app: sm-phpmyadmin
 template:
        metadata:
         labels:
           app: sm-phpmyadmin
        spec:
         containers:
           - name: sm-phpmyadmin
             image: phpmyadmin/phpmyadmin
             ports:
               - containerPort: 80
             env:
               - name: PMA_HOST
                 value: sm-mysql
               - name: PMA_PORT
                 value: "3306"
               - name: MYSQL_ROOT_PASSWORD
                 valueFrom:
                   secretKeyRef:
                     name: sm-mysql-secret
                     key: sm-mysql-root-pass
               - name: PMA_USER
                 valueFrom:
                   secretKeyRef:
                     name: sm-mysql-secret
                     key: sm-mysql-smuser
               - name: PMA_PASSWORD
                 valueFrom:
                   secretKeyRef:
                     name: sm-mysql-secret
                     key: sm-mysql-smpass

Luego necesitamos ejecutar este archivo con kubectl, para generar nuestro componente:

kubectl apply -f sm-phpmyadmin-deploy.yaml

5.2) Service

Finalmente, necesitamos configurar nuestro servicio PhpMyAdmin externo, que permitirá la obtener solicitudes desde fuera del clúster con el navegador de nuestra maquina local.

touch sm-phpmyadmin-service.yaml

apiVersion: v1
kind: Service
metadata:
 name: sm-phpmyadmin
spec:
 type: NodePort
 selector:
        app: sm-phpmyadmin
 ports:
 - protocol: TCP
        port: 80
        targetPort: 80

Nota: El uso de NodePort no es seguro para un entorno de producción porque estamos exponiendo el nodo directamente al exterior. Esto solo es adecuado para fines de desarrollo porque es fácil y rápido de implementar, pero tiene problemas de rendimiento y seguridad. En un entorno de producción, necesitaríamos usar el componente Kubernetes Ingress o configurar un servicio LoadBalancer, que es proporcionado por Kubernetes y también por muchos proveedores de la nube.

Luego necesitamos ejecutar este archivo con kubectl, para generar nuestro componente:

kubectl apply -f sm-phpmyadmin-service.yaml

5.3) Test

Podemos ver si nuestros componentes se crearon correctamente y se están ejecutando actualmente:

kubectl get deployments

kubectl get services

kubectl get pods

Ahora podemos acceder al panel de PhpMyAdmin con nuestro navegador. Para encontrar la URL correcta, necesitamos obtener el puerto del nodo que está expuesto por el servicio NodePort en nuestro clúster de Minikube:

minikube service list

A la derecha podemos ver la URL completa para acceder al panel de phpmyadmin. Lo copiamos y pegamos en el navegador:

6) Componentes Node.js

A continuacion implementaremos los componentes de Kubernetes relativos al servidor Node.js.

6.1) Deployment

Vamos a utilizar nuestra imagen Docker "nodejs-studentmanagement" generada en la guía anterior. Expondremos el puerto 8080 del contenedor y estableceremos las variables de entorno de nuestro componente Secret, que, como podemos recordar, contiene las credenciales para la conexión MySQL.

touch sm-nodejs-deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
 name: sm-nodejs
spec:
 replicas: 1
 selector:
        matchLabels:
         app: sm-nodejs
 template:
        metadata:
         labels:
           app: sm-nodejs
        spec:
         containers:
           - name: sm-nodejs
             image: nodejs-studentmanagement
             imagePullPolicy: Never
             ports:
               - containerPort: 8080
             env:
               - name: MYSQL_HOST
                 value: sm-mysql
               - name: MYSQL_PORT
                 value: "3306"
               - name: MYSQL_USER
                 valueFrom:
                   secretKeyRef:
                     name: sm-mysql-secret
                     key: sm-mysql-smuser
               - name: MYSQL_PASS
                 valueFrom:
                   secretKeyRef:
                     name: sm-mysql-secret
                     key: sm-mysql-smpass
               - name: MYSQL_DB
                 valueFrom:
                   secretKeyRef:
                     name: sm-mysql-secret
                     key: sm-mysql-db

Luego necesitamos ejecutar este archivo con kubectl, para generar nuestro componente:

kubectl apply -f sm-nodejs-deploy.yaml

Por defecto, minikube carga imágenes de nuestro sistema de gestión de contenedores que en nuestro caso es Docker, por lo que intentará obtener las imágenes de DockerHub. La imagen "nodejs-studentmanagement" se almacena localmente y no está en DockerHub. Por lo tanto, necesitamos especificar eso con la línea "imagePullPolicy: Never" en este archivo yaml. Además, en nuestra terminal necesitamos configurar la variable de entorno del shell para reutilizar el Docker Daemon desde minikube con el comando:

eval $(minikube docker-env)

6.2) Service

Finalmente, necesitamos configurar nuestro servicio externo nodejs, que permitirá la posibilidad de obtener solicitudes desde fuera del clúster con herramientas como Postman o navegador web.

touch sm-nodejs-service.yaml

apiVersion: v1
kind: Service
metadata:
 name: sm-nodejs
spec:
 type: NodePort
 selector:
        app: sm-nodejs
 ports:
        - protocol: TCP
         port: 8080
         targetPort: 8080

Luego necesitamos ejecutar este archivo con kubectl, para generar nuestro componente:

kubectl apply -f sm-nodejs-service.yaml

6.3) Test

Podemos ver si nuestros componentes se crearon correctamente y se están ejecutando actualmente:

kubectl get deployments

kubectl get services

kubectl get pods

Ahora podemos acceder a la ruta la API con nuestro navegador o Postman. Para encontrar la URL correcta, necesitamos obtener el puerto del nodo que está expuesto por el servicio NodePort en nuestro clúster de Minikube:

minikube service list

A la derecha podemos ver la URL completa para acceder a la API de NodeJS. Lo copiamos y pegamos en el navegador:

Está funcionando y está recibiendo correctamente las solicitudes. Podemos probarlo yendo a la ruta de los estudiantes en nuestro navegador:

Nos muestra que no puede realizar la peticion GET. Para ver que esta fallando, revisaremos los registros de nuestro pod sm-nodejs con el siguiente comando:

kubectl logs sm-nodejs-7575777b4b-4p2zl

El error nos dice que no puede encontrar la tabla student en studentmanagementdb. Eso es correcto porque no creamos ni preparamos la tabla.
Para ello, solo tenemos que configurar nuestra base de datos de la misma forma que lo hicimos en la guía anterior.

7) Configurando la base de datos

Ahora usamos nuestra base de datos "studentmanagementdb" y hacemos una consulta SQL para crear nuestra tabla de estudiantes:

CREATE DATABASE studentmanagement;
USE studentmanagement;
CREATE TABLE student (student_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,student_name VARCHAR(50),student_email VARCHAR(100), student_phone VARCHAR(15));

Además, necesitamos nuestro procedimiento almacenado para identificar las solicitudes de agregar/editar:

DELIMITER //

CREATE PROCEDURE `studentAddOrEdit`(
IN _student_id INT,
IN _student_name VARCHAR(50),
IN _student_email VARCHAR(100),
IN _student_phone VARCHAR(15)
)
BEGIN
IF _student_id = 0 THEN
INSERT INTO student(student_name,student_email,student_phone)
VALUES (_student_name,_student_email,_student_phone);
ELSE
UPDATE student
SET
student_name = _student_name,
student_email = _student_email,
student_phone = _student_phone
WHERE student_id = _student_id;
END IF;
SELECT _student_id AS 'student_id';
END //

Nos aseguramos de que se haya creado correctamente navegando a la pestaña Rutinas:

Ahora todo debería estar funcionando. Vamos a crear un alumno desde PhpMyAdmin. Para hacer esto, navegamos a nuestra tabla y luego presionamos la pestaña Insertar:

8) Probando nuestra aplicacion

Ahora podemos hacer una peticion GET para sacar a nuestros estudiantes con Postman:

Podemos hacer una peticion POST para registrar un estudiante:

Podemos obtener a nuestros estudiantes con el navegador, que realiza solicitudes GET de forma predeterminada:

Podemos editar un alumno con una peticion PUT:

Podemos obtener un alumno específico:

Finalmente podemos eliminar a un estudiante:

Podemos visualizar en el navegador el estudiante restante tras la eliminacion previa:

9) Escalando el Deployment Node.js

Podemos escalar fácilmente el Deployment de Node.js modificando el archivo sm-nodejs-deploy.yaml, cambiando el atributo "réplicas" a la cantidad deseada.
Otra forma es usando nuestro terminal. Vamos a escalar a 3 réplicas:

kubectl scale deployment sm-nodejs --replicas=3

Ahora verificamos que hemos escalado con éxito nuestra aplicación Node.js:

kubectl get deployments

Podemos ver que la implementación de "sm-nodejs" tiene 3/3 pods en ejecución.

kubectl get pods

Finalmente, podemos ver que tenemos 3 pods sm-nodejs y 2 de ellos fueron instanciados recientemente, lo que demuestra que nuestro escalado fue exitoso.

Conclusion

En esta oportunidad introducimos una tecnología muy poderosa para organizar y orquestrar contenedores.
Primero, instalamos kubectl, que es una interfaz de línea de comandos para ejecutar comandos en clústeres de Kubernetes. Luego configuramos Minikube, que es una utilidad que podemos usar para ejecutar Kubernetes en nuestra máquina local. Despues, revisamos algunos de los conceptos principales de Kubernetes y luego visualizamos los componentes principales que necesitábamos para configurar nuestra arquitectura de Kubernetes. Luego nos ensuciamos las manos escribiendo los archivos yaml para finalmente tener nuestro sistema funcionando correctamente, como muestra el diagrama de arquitectura. Por ultimo probamos nuestra API con algunos ejemplos y escalamos nuestra aplicación Node.js para ejecutar 3 instancias de la misma.

Espero que te haya sido de utilidad esta serie de guias!

Guía Practica de Contenedores: Contenerizando nuestra API con Docker y Docker Compose (2/3)

crisemcon — Mon, 04 Oct 2021 22:15:47 +0000

(Esta es la segunda parte de una guía practica sobre contenedores que abarca el desarrollo de un API CRUD, el uso de Docker para la contenerizacion de la aplicación, la incorporación de Docker Compose para la sincronización de múltiples contenedores, y finalmente Kubernetes para la orquestación de los contenedores que conforman la aplicación que desarrollaremos.) Codigo Fuente

En esta oportunidad utilizaremos Docker para construir una imagen de Node.js que incluya nuestra API CRUD desarrollada en la guía anterior. Luego ejecutaremos el contenedor y descubriremos la necesidad de incorporar mas contenedores. Debido a esto, utilizaremos Docker Compose para ejecutar en simultaneo 3 contenedores: Uno ejecutando nuestro servidor Node.js, otro ejecutando MySQL y el ultimo ejecutando PhpMyAdmin. Esto se puede visualizar en el siguiente diagrama:

1) Requisitos

Primero instalaremos las tecnologías necesarias para el desarrollo de esta guía: Docker y Docker-Compose.
Si ya posees las tecnologías mencionadas anteriormente y las de la primera parte de la guía, puedes saltarte a la sección 2

1.1) Instalando Docker

Existen varios métodos para instalar Docker, pero en esta guía instalaremos Docker usando el repositorio.
Primero, configuramos el repositorio con los siguientes comandos de terminal:

sudo apt-get update
sudo apt-get install \
   apt-transport-https \
   ca-certificates \
   curl \
   gnupg \
   lsb-release

Luego agregamos la clave GPG oficial de Docker con:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

El siguiente paso es configurar el repositorio estable:

echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Finalmente instalamos la última versión de Docker Engine y Containerd:

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

Podemos verificar que Docker Engine está instalado correctamente ejecutando la imagen hello-world:

sudo docker run hello-world

Mas detalles acerca este paso en: https://docs.docker.com/engine/install/ubuntu/

1.2) Instalando Docker Compose

Primero, descargamos la versión estable actual de Docker Compose:

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Luego aplicamos permisos ejecutables al binario:

sudo chmod +x /usr/local/bin/docker-compose

Finalmente verificamos la versión de Docker Compose para comprobar que la instalacion fue exitosa:

docker-compose --version

Mas detalles acerca este paso en: https://docs.docker.com/compose/install/

2) Contenerizando nuestra aplicación Node.js

Primero necesitamos crear un Dockerfile (documento de texto que contiene todos los comandos que un usuario puede llamar en la línea de comandos para ensamblar una imagen) en nuestro directorio de proyecto:

touch Dockerfile

FROM node:14

WORKDIR /app

COPY package*.json ./

RUN npm install
RUN npm install -g nodemon

COPY script.js ./

CMD ["nodemon","script.js"]

La primera sentencia indica que vamos a utilizar Node.js v14 como nuestra imagen base.
Luego configuramos nuestro directorio de trabajo, que en nuestro caso será una carpeta llamada “app” y contendrá nuestros archivos.
A continuación copiamos tanto package.json como package-lock.json en nuestro directorio de trabajo. Este archivo contiene los nombres de los paquetes necesarios para ejecutar nuestra aplicación.
Luego queremos que el contenedor instale las dependencias con el comando RUN. Además, copiamos nuestro archivo principal “script.js”.
Finalmente le decimos al contenedor que ejecute el comando “nodemon script.js” para iniciar el servidor cuando el contenedor comience a ejecutarse.

Ahora construimos nuestra imagen con el siguiente comando:

sudo docker build -t node-restapi .

Deberíamos obtener una respuesta como la siguiente:

Como recordamos, configuramos nuestro servidor para que se ejecute en el puerto 8080. Sin embargo, ahora ese será el puerto dentro del contenedor.
Entonces, cuando queremos ejecutar nuestro contenedor, tenemos que adjuntar un puerto de nuestra máquina local al puerto del contenedor.
Eso se logra con el parámetro “-p 7000: 8080”. En ese caso, el puerto 7000 se conectará al puerto 8080 del contenedor.
Además, queremos ejecutar el contenedor con una terminal interactiva para imprimir el estado del servidor. Para eso, agregamos el parámetro “-it”. El comando completo es el siguiente:

sudo docker run -it -p 7000:8080 node-restapi

En el log mostrado en la terminal podemos apreciar que nuestro contenedor no se pudo conectar correctamente a la base de datos. Esto sucede porque el contenedor no tiene nuestra base de datos, pues está en nuestra máquina local. Esto sera resuelto en la siguiente sección mediante Docker Compose.

Ahora nuestro contenedor se está ejecutando. Abrimos otra terminal para ver todos los contenedores en ejecución:

sudo docker ps

Si intentamos realizar una petición GET a la ruta http://localhost:7000/students, vemos el siguiente error en la terminal del contenedor:

Esa es una buena señal. Nuestro servidor intenta manejar la petición, pero registra un error porque no puede conectarse a la base de datos para consultar la solicitud. Esto es lo que vamos a resolver en el siguiente apartado.

3) Contenerizando nuestra base de datos y sincronizando nuestra aplicación basada en contenedores con Docker Compose

En esta sección vamos a ejecutar 3 contenedores simultáneamente:

Servidor Node.js
Base de datos MySql
Administrador de base de datos PhpMyAdmin.

Primero, necesitamos hacer un par de cambios en algunos archivos. Editemos nuestro archivo script.js, específicamente el objeto mysqlConnection:

Antes:

//MySQL details
var mysqlConnection = mysql.createConnection({
 host: "localhost",
 user: "root",
 password: "password",
 database: "studentmanagement",
 multipleStatements: true,
});

Despues:

var mysqlHost = process.env.MYSQL_HOST || 'localhost';
var mysqlPort = process.env.MYSQL_PORT || '3306';
var mysqlUser = process.env.MYSQL_USER || 'root';
var mysqlPass = process.env.MYSQL_PASS || 'password';
var mysqlDB = process.env.MYSQL_DB || 'studentmanagement';

//MySQL details
var mysqlConnection = mysql.createConnection({
 host: mysqlHost,
 port: mysqlPort,
 user: mysqlUser,
 password: mysqlPass,
 database: mysqlDB,
 multipleStatements: true,
});

Este cambio es para usar la variable de entorno del contenedor para configurar el usuario, la contraseña, el puerto, el host y la base de datos de MySQL.

Anteriormente, expusimos el puerto 8080 del contenedor manualmente en la terminal, pero puede ser configurado en el Dockerfile:

Antes:

FROM node:14

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY script.js ./

CMD ["node","script.js"]

Despues:

FROM node:14

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY script.js ./

EXPOSE 8080

CMD ["node","script.js"]

Ahora construimos nuestra nueva imagen con el siguiente comando:

sudo docker build . -t nodejs-studentmanagement

Luego vamos a crear el archivo docker-compose.yml, que describe los servicios, redes, variables de entorno y comunicación entre los contenedores:

touch docker-compose.yml

Como mencionamos, necesitamos tres servicios: nodejs, mysql y phpmyadmin. Además, vamos a tener dos redes: frontend y backend. La red de backend contendrá los tres servicios y la red de frontend solo el servicio Node.js.

Además, conectaremos el puerto 30001 al 8080 de nuestro contenedor Node.js y el puerto 30002 al puerto 80 del servicio PhpMyAdmin. El archivo docker-compose.yml debe contener lo siguiente:

La imagen de MySQL 5.7 habilita por defecto el puerto 3306 para conexiones entrantes, mientras que PhpMyAdmin habilita por defecto el puerto 80 para conexiones entrantes.

version: "3.2"
services:
        nodejs:
           build:
               context: .
           image: nodejs-studentmanagement
           depends_on:
               - mysql
           networks:
               - frontend
               - backend
           environment:
               - MYSQL_HOST=mysql-studentmanagement
               - MYSQL_USER=smuser
               - MYSQL_PASS=smpass
               - MYSQL_DB=studentmanagementdb
           volumes:
               - ./www/:/var/www/html
           ports:
               - "30001:8080"
           container_name: nodejs-studentmanagement
        mysql:
           image: mysql:5.7
           networks:
               - backend
           environment:
               - MYSQL_ROOT_PASSWORD=root
               - MYSQL_USER=smuser
               - MYSQL_PASSWORD=smpass
               - MYSQL_DATABASE=studentmanagementdb
           container_name: mysql-studentmanagement
        phpmyadmin:
           image: phpmyadmin/phpmyadmin:4.7
           depends_on:
               - mysql
           networks:
               - backend
           ports:
               - "30002:80"
           environment:
               - PMA_HOST=mysql-studentmanagement
               - PMA_PORT= 3306
           volumes:
               - /sessions
           container_name: phpmyadmin-studentmanagement
networks:
        frontend:
        backend:

Finalmente usamos docker-compose para construir y ejecutar los tres contenedores, manteniendo las dependencias entre ellos:

sudo docker-compose up

Ahora los tres contenedores están funcionando.
A continuacion necesitamos configurar la base de datos. Para ello, utilizaremos PhpMyAdmin, que está adjunto al puerto 30002.
Abrimos nuestro navegador y navegamos a http: //localhost:30002 e iniciamos sesión con las credenciales descritas en el docker-compose.yml:

User: smuser
Password: smpass

Ahora usamos nuestra base de datos "studentmanagementdb" y hacemos una consulta SQL para crear nuestra tabla de estudiantes:

CREATE DATABASE studentmanagement;
USE studentmanagement;
CREATE TABLE student (student_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,student_name VARCHAR(50),student_email VARCHAR(100), student_phone VARCHAR(15));

Además, necesitamos nuestro procedimiento almacenado para identificar las solicitudes de agregar/editar:

DELIMITER //

CREATE PROCEDURE `studentAddOrEdit`(
IN _student_id INT,
IN _student_name VARCHAR(50),
IN _student_email VARCHAR(100),
IN _student_phone VARCHAR(15)
)
BEGIN
IF _student_id = 0 THEN
INSERT INTO student(student_name,student_email,student_phone)
VALUES (_student_name,_student_email,_student_phone);
ELSE
UPDATE student
SET
student_name = _student_name,
student_email = _student_email,
student_phone = _student_phone
WHERE student_id = _student_id;
END IF;
SELECT _student_id AS 'student_id';
END //

Nos aseguramos de que se haya creado correctamente navegando a la pestaña Rutinas:

4) Probando nuestra API con Postman

Podemos hacer una petición POST para registrar un estudiante con Postman:

Podemos hacer una petición POST para registrar otro estudiante:

Podemos realizar una petición GET para obtener los estudiantes con el navegador, que realiza peticiones HTTP GET por defecto al navegar a una dirección:

Podemos editar un alumno con una petición PUT:

Podemos obtener un alumno específico con una petición GET:

Podemos eliminar a un estudiante con una petición DELETE:

Finalmente podemos visualizar los estudiantes desde el navegador para verificar el resultado final:

Conclusion

En esta segunda parte de la guia utilizamos Docker para construir una imagen de Node.js con nuestro programa y ejecutamos nuestro propio contenedor. Tras esto surgio la necesidad de conectar el contenedor a una base de datos, por lo que utilizamos Docker Compose para ejecutar en simultaneo 3 contenedores: el servidor Node.js, la base de datos MySql y el administrador de base de datos PhpMyAdmin.
En la siguiente guia migraremos nuestra aplicacion multicontenedor de Docker Compose a una arquitectura de Kubernetes.

Espero que te haya sido de utilidad esta guia y nos vemos en la siguiente!

Guía Practica de Contenedores: Desarrollando una API CRUD con Node.js, Express y MySQL (1/3)

crisemcon — Mon, 04 Oct 2021 22:13:00 +0000

(Esta es la primera parte de una guía practica sobre contenedores que abarca el desarrollo de un API CRUD, el uso de Docker para la contenerizacion de la aplicación, la incorporación de Docker Compose para la sincronización de múltiples contenedores, y finalmente Kubernetes para la orquestación de los contenedores que conforman la aplicación que desarrollaremos.) Codigo Fuente

En esta oportunidad desarrollaremos una API simple, incluyendo las principales operaciones CRUD (Create, Read, Update y Delete). Esta API actuara como un servicio para la gestión de estudiantes.
Primero instalaremos las tecnologías necesarias para crear nuestra aplicación:

1) Requisitos

Primero instalaremos las tecnologías necesarias para el desarrollo de esta guia: Ubuntu, Node.js, MySQL y Postman.
Si ya posees las tecnologias mencionadas anteriormente, puedes saltarte a la seccion 2

1.1) Instalando Ubuntu

Usaremos Ubuntu como sistema operativo. Si eres usuario de Windows o Mac, puedes instalar una máquina virtual con este sistema operativo. En nuestro caso, instalaremos Linux Ubuntu como nuestro sistema operativo principal.
Para esto, descargamos la imagen ISO oficial de Ubuntu en: https://ubuntu.com/download/desktop y la grabamos en una unidad USB usando Rufus, herramienta que puede ser descargada aquí: https://rufus.ie/en_US/.
Luego, iniciamos la unidad USB en el arranque e instalamos Ubuntu.

Más detalles sobre este paso en: https://turbofuture.com/computers/How-to-Create-a-Bootable-USB-Ubuntu-Installer-in-Windows

1.2) Instalando Node.js

Si visitamos el sitio web oficial de Node.js (https://nodejs.org/), podemos ver la última versión estable, denominada LTS (Long Term Support).
A momento de escribir esta guía, 14.16.1 es la última versión estable de Node.js. Entonces, primero, instalaremos un PPA para tener acceso a sus paquetes.

cd ~
curl -sL https://deb.nodesource.com/setup_14.x -o nodesource_setup.sh
sudo bash nodesource_setup.sh

El PPA se agregará a nuestra configuración y nuestra caché de paquetes locales se actualizará automáticamente. Ahora instalamos Node.js.

sudo apt install nodejs

Podemos verificar la versión que tenemos instalada ejecutando el comando:

node -v

Además, este proceso instalará npm, que es un administrador de paquetes para Node.js. Podemos verificar la versión de npm con:

npm -v

Más detalles sobre este paso en: https://www.digitalocean.com/community/tutorials/how-to-install-node-js-on-ubuntu-20-04-es

1.3) Instalando MySQL

Para instalar MySQL en la máquina utilizaremos el repositorio de paquetes APT. Escribimos en la terminal los siguientes comandos:

sudo apt update
sudo apt install mysql-server

Mas detalles sobre este paso en: https://www.digitalocean.com/community/tutorials/how-to-install-mysql-on-ubuntu-20-04-es

1.4) Instalando Postman

La forma más sencilla para instalar Postman en Ubuntu es mediante el sistema de gestión de paquetes Snappy. Los Snaps son paquetes de software autónomos que incluyen el binario de todas las dependencias necesarias para ejecutar la aplicación. Los paquetes Snap se pueden instalar desde la línea de comandos o mediante la aplicación de software de Ubuntu.
Para instalar el complemento Postman, abrimos nuestra terminal y ejecutamos el siguiente comando:

sudo snap install postman

Mas detalles sobre este paso en: https://linuxize.com/post/how-to-install-postman-on-ubuntu-20-04/

2) Creando nuestro proyecto

El directorio de nuestro proyecto tendrá la siguiente estructura:

studentmanagementcrud
- package.json
- script.js

Para lograr esto, creamos nuestro directorio de proyecto e inicializamos la configuración del proyecto:

mkdir studentmanagementcrud
npm -y init

Esto creará nuestro archivo package.json. Ahora necesitamos instalar los paquetes necesarios para este proyecto:

express.js: Framework web.
mysql: Controlador Node.js para MySQL.
nodemon: Herramienta que permite reiniciar automáticamente el servidor cada vez que existen cambios en el código.

npm i --s express express-handlebars mysql

Además, queremos instalar nodemon globalmente, para que pueda acceder a cualquier archivo en nuestra máquina:

npm i -g nodemon

Una vez que hayamos terminado de instalar los paquetes, el archivo package.json debería verse así:

{
  "name": "studentmanagementcrud",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.17.1",
    "express-handlebars": "^5.3.0",
    "mysql": "^2.18.1",
  }
}

3) Creando la base de datos

Necesitamos crear una base de datos MySQL "studentmanagement" con una sola tabla llamada "student". Para ello, introducimos los siguientes comandos en la terminal:

sudo mysql

CREATE DATABASE studentmanagement;
USE studentmanagement;
CREATE TABLE student (student_id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,student_name VARCHAR(50),student_email VARCHAR(100), student_phone VARCHAR(15));

Además, vamos a utilizar un procedimiento almacenado (Stored Procedure) en nuestra base de datos, el cual procesara nuestras solicitudes de inserción o actualización. Ya estamos dentro de mysql en nuestra terminal, así que usamos este comando:

DELIMITER //

CREATE DEFINER=`root`@`localhost` PROCEDURE `studentAddOrEdit`(
IN _student_id INT,
IN _student_name VARCHAR(50),
IN _student_email VARCHAR(100),
IN _student_phone VARCHAR(15)
)
BEGIN
IF _student_id = 0 THEN
INSERT INTO student(student_name,student_email,student_phone)
VALUES (_student_name,_student_email,_student_phone);
ELSE
UPDATE student
SET
student_name = _student_name,
student_email = _student_email,
student_phone = _student_phone
WHERE student_id = _student_id;
END IF;
SELECT _student_id AS 'student_id';
END //

4) Creando la API

A continuación crearemos un archivo llamado script.js, el cual actuara como el punto de entrada de nuestra aplicación y contiene todos los endpoints y controladores. La ejecución de este programa invocara al servidor habilitando un puerto para el acceso de peticiones HTTP y establecerá la conexión con la base de datos creada anteriormente.

Entonces, en el directorio de nuestro proyecto, ejecutamos el siguiente comando:

touch script.js

Este archivo debe contener el siguiente código, el cual posee comentarios para describir su funcionalidad:

const mysql = require("mysql");
const express = require("express");

var app = express();
//Configuring express server
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

//MySQL details
var mysqlConnection = mysql.createConnection({
  host: "localhost",
  user: "root",
  password: "password",
  database: "studentmanagement",
  multipleStatements: true,
});

mysqlConnection.connect((err) => {
  if (!err) console.log("Connection Established Successfully");
  else console.log("Connection Failed!" + JSON.stringify(err, undefined, 2));
});

//Establish the server connection
//PORT ENVIRONMENT VARIABLE
const port = process.env.PORT || 8080;
app.listen(port, () => console.log(`Listening on port ${port}..`));

//Creating GET Router to fetch all the student details from the MySQL Database
app.get("/students", (req, res) => {
  mysqlConnection.query("SELECT * FROM student", (err, rows, fields) => {
    if (!err) res.send(rows);
    else console.log(err);
  });
});

//Router to GET specific student detail from the MySQL database
app.get("/students/:id", (req, res) => {
  mysqlConnection.query(
    "SELECT * FROM student WHERE student_id = ?",
    [req.params.id],
    (err, rows, fields) => {
      if (!err) res.send(rows);
      else console.log(err);
    }
  );
});

//Router to INSERT/POST a student's detail
app.post("/students", (req, res) => {
  let student = req.body;
  if(student.student_id === undefined){
    student.student_id = 0;
  }
  var sql =
    "SET @student_id = ?;SET @student_name = ?;SET @student_email = ?;SET @student_phone = ?; CALL studentAddOrEdit(@student_id,@student_name,@student_email,@student_phone);";
  mysqlConnection.query(
    sql,
    [
      student.student_id,
      student.student_name,
      student.student_email,
      student.student_phone,
    ],
    (err, rows, fields) => {
      if (!err) res.send("Student Created Successfully");
      else console.log(err);
    }
  );
});

//Router to UPDATE a student's detail
app.put("/students", (req, res) => {
  let student = req.body;
  var sql =
    "SET @student_id = ?;SET @student_name = ?;SET @student_email = ?;SET @student_phone = ?; CALL studentAddOrEdit(@student_id,@student_name,@student_email,@student_phone);";
  mysqlConnection.query(
    sql,
    [
      student.student_id,
      student.student_name,
      student.student_email,
      student.student_phone,
    ],
    (err, rows, fields) => {
      if (!err) res.send("Student Details Updated Successfully");
      else console.log(err);
    }
  );
});

//Router to DELETE a student's detail
app.delete("/students/:id", (req, res) => {
  mysqlConnection.query(
    "DELETE FROM student WHERE student_id = ?",
    [req.params.id],
    (err, rows, fields) => {
      if (!err) res.send("Student Record deleted successfully.");
      else console.log(err);
    }
  );
});

Nuestro programa necesita conectarse con nuestra base de datos MySQL. Pero, para hacer esto, debemos asegurarnos de tener una contraseña adecuada en MySQL. De forma predeterminada, el usuario es "root" y la contraseña es "root". Necesitamos establecer una contraseña que coincida con la establecida en el código. En nuestro caso el usuario es "root" y la contraseña es "password". Para lograr esto, se ejecutan los siguientes comandos en la sesión de mysql:

ALTER USER 'root'@'localhost' IDENTIFIED BY 'password';
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';
FLUSH PRIVILEGES;

A continuacion ejecutaremos el servidor para que comience a esperar solicitudes en el puerto 8080. En el directorio del proyecto abrimos la terminal y ejecutamos:

nodemon script.js

Esto deberia mostrar el siguiente mensaje:

Ahora podemos comenzar a enviar peticiones HTTP a nuestro servidor, que está escuchando en el puerto 8080. Para esto, usaremos Postman:

5) Probando nuestra API con Postman

En este apartado realizaremos las peticiones HTTP a nuestra API con Postman, y confirmaremos su resultado con la terminal MySQL.
Vamos a crear un estudiante con una peticion POST en la ruta http://localhost:8080/students:

Podemos obtener todos los estudiantes registrados con una peticion GET en la ruta http://localhost:8080/students: (He creado otro estudiante siguiendo el proceso descrito en el paso anterior)
![get students postman]

Podemos editar un alumno con una peticion PUT en la ruta http://localhost:8080/students:

Podemos obtener un estudiante específico con una peticion GET en la ruta http://localhost:8080/students/:id de la siguiente manera:

Podemos eliminar un estudiante específico con una peticion DELETE en la ruta http://localhost:8080/students/:id de la siguiente manera:

Conclusion

En esta primera parte de la guia practica de contenedores creamos un servidor local usando Node.js, Express y MySQL, y finalmente probamos la funcionalidad de nuestra API con la herramienta Postman.
En la siguiente guia utilizaremos Docker para construir una imagen de Node.js que incluya nuestro programa y ejecutar nuestro propio contenedor. Ademas, utilizaremos Docker Compose para ejecutar en simultaneo 3 contenedores.

Espero que te haya sido de utilidad esta guia y nos vemos en la siguiente!