DEV Community: Luis_Zapata_Yamo

Implementación de una Aplicación SpringBoot Utilizando Docker y Jenkins (Docker-outside-of-Docker - DooD)

Luis_Zapata_Yamo — Tue, 11 Jun 2024 05:52:47 +0000

Inicialmente tenemos que instalar docker en nuestra maquina host, en este caso estoy en windows, Docker Desktop.

Importante entrar a docker desktop y habilitar en settings

Para fines prácticos se ha realizado pasos que se podrían mejorar usando nodos en Jenkins.

Usaremos el concepto de construcción de contenedores a partir de DockerFiles y usando Docker compose.

Lo que haremos es un flujo para que cuando realicemos un push a nuestro repositorio remoto Jenkins pueda iniciar un pipeline que permita la creación de un contenedor de una aplicación.

Creación de contenedor Jenkins y Base de datos

DockerFile.jenkinslocal

Este primer DockerFile es para el contenedor Jenkins, llamado DockerFile.jenkinslocal.

# Utiliza la imagen oficial de Jenkins
FROM jenkins/jenkins:lts

# Cambia al usuario root para instalar paquetes
USER root

# Instala wget, dpkg y dependencias necesarias
RUN apt-get update && apt-get install -y wget dpkg apt-transport-https ca-certificates curl gnupg2 software-properties-common

# Instala Java
RUN apt-get install -y java-common


# Descarga e instala Amazon Corretto 17
ADD https://corretto.aws/downloads/latest/amazon-corretto-17-x64-linux-jdk.deb /tmp/

RUN dpkg -i /tmp/amazon-corretto-17-x64-linux-jdk.deb

# Limpia el cache de apt y elimina el paquete de instalación de Corretto
RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/amazon-corretto-17-x64-linux-jdk.deb

# Descarga e instala Maven
ADD https://dlcdn.apache.org/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz /opt/

RUN tar -xzf /opt/apache-maven-3.9.6-bin.tar.gz -C /opt/

ENV PATH="/opt/apache-maven-3.9.6/bin:${PATH}"

# Instala Docker CLI
RUN curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -

RUN add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"

RUN apt-get update && apt-get install -y docker-ce-cli


# Agrega el usuario de Jenkins al grupo docker
RUN groupadd docker

RUN usermod -aG docker jenkins

# Cambia al usuario de Jenkins
USER jenkins

Se necesita tener instalado en el contenedor de jenkins:

Dependencias necesarias
Java, en este caso usando Amazon Coretto 17
Maven
El daemon de docker

Creación del docker-compose.yml

Este docker file sera usado dentro del docker-compose.yml y dentro también crearemos el contenedor de la base de datos con parámetros establecidos para crear una bd inicial llamada crud.

version: '3.8'

services:
  jenkinslocal:
    container_name: jenkinslocal
    build:
      context: .
      dockerfile: Dockerfile.jenkinslocal
    ports:
      - "8080:8080"
      - "500:5000"
    environment:
      JAVA_OPTS: "-Djenkins.install.runSetupWizard=false"
      DOCKER_HOST: "tcp://host.docker.internal:2375"
    depends_on:
      - postgres

    volumes:
      - jenkins_home:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

  postgres:
    container_name: db-crud
    image: postgres
    restart: always
    ports:
      - "5432:5432"
    environment:
      POSTGRES_DB: crud
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres

volumes:
  jenkins_home:

El primer servicio es para el contenedor de jenkins:

Se crea a partir del DockerFile.jenkinslocal
se habilitan los puertos
Se agrega el host del docker
Y como volumen se incluye la ruta del socket de docker

El segundo servicio es para el contenedor de docker es para la base de datos, en postgres.

Se crea a partir de la imagen de postgres
Se habilitan los puertos
Se crean variables de entorno para configuraciones iniciales de la base de datos

Levantar Contenedores

Para poder levantar el docker compose se usa:

docker compose up -d

Si hacemos cambios en el internos en los servicios tenemos que hacer:

docker compose down
docker compose up -d (--detach/segundo plano)

Configurar Aplicación

La aplicación, en este caso una api usa el puerto 8081, adicional tendro del pom.xml se define el nombre del artefacto que se crea, llamado mi-app.jar .

Es importante saber que jenkins dentro de un contenedor necesita la ip del host local

Para SpringBoot el cambio de puerto se puede hacer en el archivo application.properties :

#Ejemplo
spring.application.name=crud
spring.datasource.url=jdbc:postgresql://ip_local:5432/crud
spring.datasource.username=postgres
spring.datasource.password=postgres
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
spring.jpa.hibernate.ddl-auto=update
server.port=8081

Para el pom en este caso se uso el finalName:

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                    <finalName>mi-app</finalName>
                </configuration>
            </plugin>
        </plugins>
    </build>

Creación del DockerFile para la aplicación

Requisitos para la app:

Instalar y configurar Java
Jar que se genera en el pipeline

# Dockerfile para el contenedor app-crud
FROM debian:bullseye-slim

# Instala wget y dpkg
RUN apt-get update && apt-get install -y wget && apt-get install -y dpkg
RUN apt-get update && apt-get install -y java-common


# Descarga e instala Amazon Corretto 17
ADD https://corretto.aws/downloads/latest/amazon-corretto-17-x64-linux-jdk.deb /tmp/

RUN dpkg -i /tmp/amazon-corretto-17-x64-linux-jdk.deb

# Limpia el cache de apt y elimina el paquete de instalación de Corretto
RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/amazon-corretto-17-x64-linux-jdk.deb

# Configura las variables de entorno JAVA_HOME y PATH
ENV JAVA_HOME /usr/lib/jvm/java-17-amazon-corretto

ENV PATH $JAVA_HOME/bin:$PATH

# Define el directorio de trabajo
WORKDIR /app

# # Copia el JAR generado a la imagen
COPY target/mi-app.jar /app/mi-app.jar

# # Comando para ejecutar la aplicación
CMD ["java", "-jar", "/app/mi-app.jar"]

Crear el JenkinsFile

Se necesita el flujo para poder hacer el despliegue.

pipeline {
    agent any
    environment {
        DOCKER_HOST = 'tcp://host.docker.internal:2375'
        CONTAINER_NAME = 'mi-app-container'
        IMAGE_NAME = 'mi-app:latest'
    }

    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }

        }

        stage('Build Docker Image') {
            steps {
                script {
                    sh 'docker build -t ${IMAGE_NAME} -f Dockerfile.app-crud .'
                }
            }
        }

        stage('Deploy Docker Container') {
            steps {
                script {
                    // Stop and remove the old container if it exists
                    sh '''
                    if [ "$(docker ps -aq -f name=${CONTAINER_NAME})" ]; then
                        if [ "$(docker ps -aq -f status=running -f name=${CONTAINER_NAME})" ]; then
                            docker stop ${CONTAINER_NAME}
                        fi
                        docker rm ${CONTAINER_NAME}
                    fi
                    '''
                    
                    // Run the new container
                    sh '''
                    docker run -d --name ${CONTAINER_NAME} -p 8081:8081 ${IMAGE_NAME}
                    '''
                }

            }

        }

    }

}

Este pipeline:

Compila la aplicación y crea el JAR (mi-app.jar).
Construye una imagen Docker.
Despliega el contenedor, deteniendo y eliminando el existente si es necesario.

Configuración de Jenkins

Cuando se crea un contenedor jenkins hay casos que te piden una clave, esta sale en el log de ejecución del contenedor. Y luego sigues los pasos hasta ver la pagina principal

Plugins

Instala los siguientes plugins en Jenkins:

Configuración del Job

Crea un nuevo Job en Jenkins con estas configuraciones:

Trigger: GitHub hook trigger for GITScm polling
Pipeline: Pipeline script from SCM
SCM: Git con URL SSH
En Repository URL le colocamos la URL pero con el protocolo SSH
En credential lo dejamos vacío por ahora.

Abriremos una terminal del contenedor de Jenkins para crear una llave ssh:

docker exec -it -u jenkins id_contenedor bash

Luego dentro de la terminal

# Comandos de ejemplo
cd ~
ssh-keygen 
Generating public/private rsa key pair.
Enter file in which to save the key (/var/jenkins_home/.ssh/id_rsa):
# Output...

eval $(ssh-agent -s)
ssh-add .ssh/id_rsa
# Reconoceremos a github para la conexion por ssh
ssh -T git@github.com

# Mostramos la llave privada
cat .ssh/id_rsa
# Mostramos la llave publica
cat .ssh/id_rsa.pub

Para agregar la llave privada a las credenciales de Jenkins hacemos los iguiente:

Abrimos la interfaz de jenkins y vamos a la configuración del job creado y agregamos una

Les saldrá una ventana asi

En Kind le colocamos SSH Username with private key
El ID debe ser único a la otras credenciales que ya tienes
En Private Key le das click en Enter directly para agregar la llave privada directamente y le damos en Add.
Luego si es que la llave tiene clave la agregamos en el campo Passphrase
Al final de dan en agregar para guardar la credencial.

La llave publica la agregaremos al repositorio remoto en Settings>Deploys Keys>Add deploy key.

Vamos al Job creado y la credencial ya podríamos escogerla sin inconvenientes.

Cuando se ejecute el pipeline se creara un contenedor y ya estaria el deploy

Project deployment with React.js and Vite in GitHub Pages

Luis_Zapata_Yamo — Sat, 22 Apr 2023 21:30:36 +0000

In this article, we will cover the practical deployment of a frontend application on GitHub Pages, step by step. It is mainly focused for personal purposes such as creating a web portfolio. Well, let's get started...

Initial installation

First, we install node.js LTS, the recommended version.

We go to a folder where we will create the project and execute the command to create a project with vite.js:

npm create vite@latest

It will show us options for creating the project:

Project name
Package name
Framework selection -> React
JavaScript variant selection -> JavaScript

Then we go to the created folder and install the dependencies:

npm install

Etapa de configuración y publicación en GitHub Page

First, we create a git repository and add the remote repository. Then we create a branch in git called gh-pages, which we can do with git checkout -b gh-pages. Then we go to the main branch.

Next, we install the dependency called gh-pages, but as a development dependency:

npm install gh-pages --save-dev

Now we configure the package.json file:

Add "homepage", which will be the link to the page on GitHub Pages, following the format http://[username].github.io/[name_repository_remote]/ example: "homepage": "https://luiszapatayamo.github.io/Test-Publish-GHPages/"
In the scripts section, we include "predeploy": "npm run build" and "deploy": "gh-pages -d dist".

{
  "name": "test",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "homepage": "https://luiszapatayamo.github.io/Test-Publish-GHPages/",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "lint": "eslint src --ext js,jsx --report-unused-disable-directives --max-warnings 0",
    "preview": "vite preview",
    "predeploy": "npm run build",
    "deploy": "gh-pages -d dist"
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  },
  "devDependencies": {
    "@types/react": "^18.0.28",
    "@types/react-dom": "^18.0.11",
    "@vitejs/plugin-react": "^4.0.0-beta.0",
    "eslint": "^8.38.0",
    "eslint-plugin-react": "^7.32.2",
    "eslint-plugin-react-hooks": "^4.6.0",
    "eslint-plugin-react-refresh": "^0.3.4",
    "gh-pages": "^5.0.0",
    "vite": "^4.3.0"
  }
}

We also modify the vite.config.js file to set the base URL. In this case, it will follow this format /name_repository_remote/:

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import svgr from 'vite-plugin-svgr'

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [react(), svgr()],
  base: '/Test-Publish-GHPages/'
})

We confirm all the changes and send them to the remote repository, then run npm run deploy. This will create a folder named dist and publish your application on GitHub Pages.

Note: Adjustments for react-router-dom

If we use react-router-dom, we need to add the basename="/[name_repository_remote]" attribute to the BrowserRouter component in your Routing.jsx file. Then, we confirm the changes, push them to the remote repository, and run npm run deploy.

<BrowserRouter basename="/Test-Publish-GHPages">
      <Routes>
        <Route index path='/' element={<Component/>}/>
      </Routes>
</BrowserRouter>

That's it! You have successfully deployed your frontend application on GitHub Pages using Vite.js.
Software: vite==4.3 , react==18.2, gh-page==5.0, node.js==18.16

Crear Pool de Conexiones con Psycopg2 y Python

Luis_Zapata_Yamo — Tue, 31 Aug 2021 03:41:47 +0000

Definición de Pool de Conexiones:

Es un conjunto limitado de conexiones hacia una base de datos, estas conexiones son reutilizables por los usuarios, este es manejado por un servidor de aplicaciones.

Aplicación:

Primero crearemos un archivo para la clase conexión , aquí pondremos todo lo referente a la conexión a la base de datos

conexion.py

Del módulo de psycopg2 importar pool

from psycopg2 import pool

Crear una clase Conexion, ya con los parámetros como HOST, USERNAME, PASSWORD, etc. Todos los parámetros como privados

class Conexion:
    __DATABASE = 'test_db'
    __USERNAME = 'postgres'
    __PASSWORD = 'admin'
    __DB_PORT = '5432'
    __HOST = '127.0.0.1'
    __MIN_CON = 1
    __MAX_CON = 5
    __pool = None**

Luego crear una classmethod, obtenerPool(), para el pool de conexiones:

#Obteniendo varias coexiones a la base de datos con pool
@classmethod
def obtenerPool(cls):
    if cls.__pool == None:
        try:
            cls.__pool = pool.SimpleConnectionPool(
                                        cls.__MIN_CON,
                                        cls.__MAX_CON,
                                        host=cls.__HOST,
                                        user=cls.__USERNAME,
                                        password=cls.__PASSWORD,
                                        port=cls.__DB_PORT,
                                        database=cls.__DATABASE)
            logger.debug(f'Creacion pool exitosa: {cls.__pool}')
            return cls.__pool
        except Exception as e:
            logger.error(f'Errror al crear el pool de conexiones: {e}')
            sys.exit()
    else:
        return cls.__pool

Luego tenemos que crear una classmethod, obtenerConexion(), para obtener del pool una conexión:

#Obteniendo la conexion del pool
@classmethod
def obtenerConexion(cls):
    conexion = cls.obtenerPool().getconn()
    logger.debug(f'Conexión obtenida del pool: {conexion}')
    return conexion

Creamos otra classmethod, liberarConexion(), para retornar la conexión al pool

#Regresar el objeto conexion al pool
@classmethod
def liberarConexion(cls, conexion):
    cls.obtenerPool().putconn(conexion)

Utilizaremos otro classmethod, cerrarConexiones(), para cerrar las conexiones

#Cerrando todas las conexiones del pool
@classmethod
def cerrarConexiones(cls):
    cls.obtenerPool().closeall()
    logger.debug(f'Cerramos todas las conexiones del pool: {cls.__pool}')

Aquí un ejemplo de como utilizar los métodos de clase

if __name__ == "__main__":
    #Obtener una conexion a partir del pool
    conexion1 = Conexion.obtenerConexion()
    conexion2 = Conexion.obtenerConexion()
    #Regresamos las conexiones al pool
    Conexion.liberarConexion(conexion1)
    Conexion.liberarConexion(conexion2)
    #Cerramos el pool
    Conexion.cerrarConexiones()
    #error el pool ya esta cerrado
    #conexion3 = Conexion.obtenerConexion()