Creación de una canalización de CI/CD con AWS, K8S, Docker, Ansible, Git, Github, Apache Maven y Jenkins

En mi artículo anterior, profundicé en el fascinante mundo de los microservicios: Patrones de arquitectura de microservicios, Parte 1: Patrones de descomposición . Este fue el comienzo de mi completa serie de artículos sobre microservicios y sus patrones.

Descripción general del contenido

• Motivación
• [Módulo 1]: Servidor virtual AWS EC2
• [Módulo 2]: Servidor Jenkins
• [Módulo 3]: Git y Github
• [Módulo 4]: Apache Maven
• [Módulo 5]: Docker
• [Módulo 6]: Ansible
• [Módulo 7]: Kubernetes
• Conclusión
• Sobre el Autor

Motivación

En este artículo, nuestro objetivo es desmitificar el proceso de CI/CD a través de una aplicación práctica. Lo guiaremos a través de un tutorial paso a paso, desglosándolo módulo por módulo, donde creará una canalización de CI/CD manualmente. Para hacer esto, aprovecharemos el poder de las herramientas DevOps contemporáneas como AWS, Docker, Kubernetes, Ansible, Git, Apache Maven y Jenkins . Entonces, ¡comencemos este viaje!

[Módulo 1]: Servidor virtual AWS EC2

Paso 1: cree una cuenta de AWS

Haga clic en el botón Crear una cuenta de AWS .

Paso 2: inicie sesión en su cuenta de AWS

Vaya a //console.aws.amazon.com/console/home. Haga clic en el botón Iniciar sesión .

Paso 3: busque el servidor virtual EC2

Elija Servidor virtual EC2 haciendo clic en Servicio EC2 .

Haga clic en el botón Iniciar instancia .

Paso 4: Configurar la sección “Nombre y etiquetas”

Vaya a la sección "Nombre y etiquetas" .

Proporcione un nombre para una nueva instancia del servidor virtual AWS EC2 en la sección "Nombre" .

También puede agregar etiquetas adicionales para su servidor virtual haciendo clic en "Agregar etiquetas adicionales" .

Paso 5: Configure la sección "Imágenes de aplicaciones y sistemas operativos (imagen de máquina de Amazon)"

Vaya a la sección "Imágenes de aplicaciones y sistema operativo (imagen de máquina de Amazon)" .

Paso 6: Configurar la sección "Tipo de instancia"

Vaya a la sección "Tipo de instancia" .

Paso 7: Configurar la sección "Configurar almacenamiento"

Vaya a la sección "Configurar almacenamiento" .

Paso 8: Configurar la sección "Configuraciones de red"

Vaya a la sección "Configuración de red" .

1. Haga clic en el botón "Crear grupo de seguridad" .
2. Agregue el nombre de su nuevo grupo de seguridad en la sección "Nombre del grupo de seguridad" .
3. Agregue una descripción de su nuevo grupo de seguridad en la sección "Descripción" .

De forma predeterminada, se puede acceder a su servidor virtual a través de ( Tipo: SSH, Protocolo: TCP, Puerto: 22 ). Si necesita tipos de conexión adicionales, agréguelos agregando reglas de grupo de seguridad entrante adicionales.

Paso 9: Configurar la sección "Par de claves (iniciar sesión)"

Vaya a la sección "Par de claves (Iniciar sesión)" .

Si aún no ha creado un "par de claves" :

1. Haga clic en el botón "Crear nuevo par de claves" .
2. Asigne un nombre a su nuevo par de claves en la sección "Nombre del par de claves" .
3. Seleccione el tipo de par de claves RSA o ED25519 . Elijo el tipo RSA .
4. Seleccione Formato de archivo de clave privada. Elección de .pem y .ppk . Elijo el formato .pem .
5. Haga clic en el botón "Crear par de claves" .
6. Aparecerá una ventana emergente que le pedirá que descargue el archivo de clave privada. Acepta y descarga el archivo a tu computadora.

Paso 10: Inicie la instancia del servidor virtual EC2

Inicie la instancia del servidor virtual EC2 haciendo clic en el botón "Iniciar instancia" .

Luego debe ir a la sección "Instancias" haciendo clic en el botón "Ver todas las instancias" .

[Módulo 2]: Servidor Jenkins

Paso 1: crear una instancia de servidor virtual AWS EC2

Siga las instrucciones de la sección [Módulo 1]: Servidor virtual AWS EC2 de este tutorial para finalizar este paso y crear una instancia de servidor virtual EC2 con el nombre JenkinsServer.

Paso 2: Conéctese a una instancia del servidor virtual AWS EC2

Vaya a la página de inicio de la Consola de AWS → Panel de la Consola de administración EC2 → Instancias.

Luego debes elegir JenkinsServer y luego hacer clic en el botón "Conectar" .

Entonces verá esta página web. Debes volver a hacer clic en el botón "Conectar" .

Paso 3: descargue el repositorio de Jenkins

1. Vaya a de descarga de Jenkins.
2. Puede ver las opciones de lanzamientos estables (LTS) y regulares (semanales). Elija la opción LTS.

   
   

3. Copie el comando “sudo get…” y ejecútelo para descargar archivos Jenkins del repositorio de Jenkins en Internet y guárdelos en la ubicación especificada en su instancia de servidor virtual EC2.

 sudo wget -O /etc/yum.repos.d/jenkins.repo //pkg.jenkins.io/redhat-stable/jenkins.repo

Paso 4: importar la clave de Jenkins

Para importar la clave de Jenkins necesitamos copiar el comando "sudo rpm..." y ejecutarlo.

 sudo rpm --import //pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

Paso 5: instale Java

Para ejecutar Jenkins, necesitamos instalar Java en nuestra instancia de servidor virtual EC2.

Para instalar Java , utilice este comando.

 sudo amazon-linux-extras install java-openjdk11 -y

Verifique si Java se instaló correctamente usando este comando:

 java -version

Paso 6: instale fontconfig

Para ejecutar Jenkins, necesita instalar fontconfig en nuestra instancia de servidor virtual EC2.

 sudo yum install fontconfig java-11-openjdk -y

Paso 7: instale Jenkins

 sudo yum install jenkins -y

Paso 8: inicie Jenkins

 sudo systemctl start jenkins

 sudo systemctl status jenkins

Paso 9: acceda a Jenkins

 //<your-ec2-ip>:8080

 sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Paso 10: crear una nueva canalización de Jenkins

Ahora, como Jenkins funciona bien, puede comenzar a crear la canalización de Jenkins. Para crear una canalización de Jenkins, debe crear un nuevo "proyecto de estilo libre". Para crear un nuevo "proyecto de estilo libre", debe ir al panel de Jenkins y hacer clic en el botón "Nuevo elemento" .

Ingrese el nombre del “proyecto Freestyle” de Github (el nombre de “pipeline” se usará más adelante) y luego haga clic en el botón “Aceptar” .

Luego proporcione la descripción de la tubería.

[Módulo 3]: Git y Github

Paso 1: instalar Git

 sudo yum install git -y

 git --version

Paso 2: abra el panel de Jenkins

Paso 3: abra el Administrador de complementos de Jenkins

Haga clic en el botón "Administrar Jenkins" y luego haga clic en el botón "Administrar complementos" .

Paso 4: busque el complemento Github Jenkins

Haga clic en el botón "Complementos disponibles" .

Busque el cuadro de búsqueda del complemento Github .

Seleccione el complemento Github .

Paso 5: instale el complemento Github Jenkins

Seleccione el complemento Github . Y luego haga clic en el botón “Instalar sin reiniciar” .

Paso 6: Configurar el complemento Github Jenkins

Luego, en la página principal, debe hacer clic en el botón "Administrar Jenkins" y luego hacer clic en el botón "Configuración global de herramientas" .

Luego haga clic en los botones “Aplicar” y “Guardar” **.**

Paso 7: integrar Git en el proceso

Simplemente cópielo y péguelo en la entrada " URL del repositorio" . Luego haga clic en los botones "Aplicar" y "Guardar" para finalizar la integración de Git con el pipeline.

Paso 8: Pruebe Git integrado en la canalización

 cd /var/lib/jenkins/workspace/{your pipeline name}

[Módulo 4]: Apache Maven

Paso 1: descargue Apache Maven

Para descargar Apache Maven, vaya al directorio "/opt" .

 cd /opt

 sudo wget //dlcdn.apache.org/maven/maven-3/3.9.4/binaries/apache-maven-3.9.4-bin.tar.gz

Paso 2: extraiga Apache Maven del archivo

 sudo tar -xvzf apache-maven-*.tar.gz

Paso 3: agregue JAVA_HOME y M2_HOME

 cd ~

Edite el archivo .bash_profile usando este comando.

 vi .bash_profile

Agregue las variables JAVA_HOME y M2_HOME.

Asigne la ruta a JDK11 para JAVA_HOME y la ruta al directorio maven para la variable M2_HOME .

 sudo find / -name java 

 source .bash_profile

Para verificar $PATH , use este comando.

 echo $PATH

Para verificar Apache Maven , utilice este comando.

 mvn -v

Paso 4: Instale el complemento Apache Maven Jenkins

Para lograr esto, siga estos pasos:

1. Vaya a "Panel de control" → "Administrar Jenkins" → "Administrar complementos" → "Disponible".
2. En el cuadro de búsqueda, ingrese "Maven" .
3. Elija el complemento "Integración de Maven" .

Y luego haga clic en el botón “Volver a la página principal” .

Paso 5: configurar el complemento Apache Maven Jenkins

Para hacerlo, siga estos pasos:

1. Vaya a "Panel de control" → "Administrar Jenkins" → "Configuración global de herramientas" → "JDK"
2. Haga clic en el botón "Agregar JDK".
3. Desmarque "Instalar automáticamente".

Luego vaya a la sección "Maven" . Haga clic en el botón "Agregar Maven" . Desmarque "Instalar automáticamente".

Luego agregue el nombre y la ruta MAVEN_HOME .

Haga clic en los botones "Aplicar" y "Guardar" .

Paso 6: integrar Apache Maven en la canalización

Para integrar Apache Maven en la canalización, debe seguir estos pasos:

1. Navegue hasta "Panel de control" → "CI_CD_Pipeline" → "Configurar" → "Pasos de compilación".
2. Haga clic en el botón "Agregar paso de compilación" .
3. Elija la opción "Invocar objetivos Maven de nivel superior" .
4. Elija "Apache-Maven" como "Versión Maven".
5. Agregue el comando "limpiar paquete" a la entrada "Objetivos" .
6. Haga clic en el botón "Avanzado" .
7. Agregue "pom.xml" a la entrada "POM" .

Finalmente, debe hacer clic en los botones "Aplicar" y "Guardar" para finalizar la integración de Apache Maven con la canalización.

Paso 7: Pruebe Apache Maven integrado en la canalización

 cd /var/lib/jenkins/workspace/{your pipeline name}/target

[Módulo 5]: Docker

Paso 1: lanzar una instancia del servidor virtual AWS EC2

Utilice las instrucciones de la sección " Iniciar una instancia de servidor virtual AWS EC2" de este tutorial para finalizar este paso. No olvide agregar una configuración de grupo de seguridad. Permite que Docker y SSH funcionen en los puertos 8080 y 22 respectivamente.

Paso 2: Conéctese a una instancia del servidor virtual AWS EC2

 sudo chown ansible-admin:ansible-admin /opt/docker

Paso 3: instale Docker en el servidor virtual Ansible EC2.

 sudo mkdir /opt/docker

 sudo yum install docker -y

Paso 4: Agregar el usuario actual al grupo Docker en el servidor virtual Ansible EC2

Debe agregar el usuario actual "ansible-admin" al grupo Docker en el servidor virtual EC2 "AnsibleServer" para otorgar privilegios de administrador a Docker.

 sudo usermod -a -G docker ansible-admin

 id ansible-admin

Paso 5: inicie Docker

 sudo systemctl start docker

 sudo systemctl status docker

Paso 6: crear un archivo Docker

Si utilizó el proyecto "Hola" que se ofreció en el módulo " [Módulo 3]: Git y Github" , entonces no necesita crear un nuevo Dockerfile ya que este repositorio de proyectos ya contiene Dockerfile.

 FROM eclipse-temurin:17-jre-jammy ENV HOME=/opt/app WORKDIR $HOME ADD hello-0.0.1-SNAPSHOT.jar $HOME ENTRYPOINT ["java", "-jar", "/opt/app/hello-0.0.1-SNAPSHOT.jar" ]

 sudo touch Dockerfile

 vim Dockerfile

Paso 7: Iniciar sesión en Docker

Ahora que su Dockerfile está preparado para su uso, continúe copiando el artefacto JAR de su proyecto de la instancia EC2 **"JenkinsServer"** y péguelo en la instancia EC2 "AnsibleServer" . Es importante tener en cuenta que esta transferencia se automatizará aún más a lo largo del proceso.

 docker login

Con esto, ha completado el proceso de inicio de sesión en Docker y ahora está listo para continuar con las pruebas.

Paso 8: Probar el entorno Docker y Dockerfile

 docker build -t hello:latest .

 docker tag hello:latest zufarexplainedit/hello:latest

 docker push zufarexplainedit/hello:latest

[Módulo 6]: Ansible

Paso 1: crear una instancia de servidor virtual AWS EC2

Siga las instrucciones de la sección [Módulo 1]: Servidor virtual AWS EC2 de este tutorial para finalizar este paso y crear una instancia de servidor virtual EC2 para Ansible.

Paso 2: Conéctese a una instancia del servidor virtual AWS EC2

Luego haga clic en el botón "Conectar" .

Entonces verá esta página web. Debes volver a hacer clic en el botón "Conectar" .

Paso 3: cambie el nombre de host de la instancia del servidor virtual AWS EC2 "AnsibleServer"

 sudo vi /etc/hostname

Reemplace este nombre de host con "ansible-server". Luego, reinícialo.

 sudo init 6 

Paso 4: Agregar y configurar un nuevo usuario en la instancia del servidor virtual AWS EC2 "AnsibleServer"

Ahora agreguemos un nuevo usuario ansible-admin a la instancia del servidor virtual AWS EC2.

 sudo useradd ansible-admin

Luego, configure la contraseña para el usuario ansible-admin .

 sudo passwd ansible-admin

Además, debe configurar los privilegios de usuario editando el archivo sudoers .

 sudo visudo

Agregue "ansible-admin ALL=(ALL) ALL" a este archivo sudoers .

Además, debe editar el archivo /etc/ssh/sshd_config para habilitar la autenticación de contraseña.

 sudo vi /etc/ssh/sshd_config 

 sudo service sshd reload

 sudo su - ansible-admin

Paso 5: Generar clave en una instancia de servidor virtual AWS EC2

 ssh-keygen

Paso 6: instalar Ansible

Ahora puede instalar Ansible en su instancia de servidor virtual EC2 “AnsibleServer” .

 sudo amazon-linux-extras install ansible2

 ansible --version

Paso 7: Instale el complemento “Publicar a través de SSH” de Jenkins en la instancia EC2 de JenkinsServer

Como Ansible está instalado en su instancia de servidor virtual EC2 “AnsibleServer” , puede configurar Jenkins para integrarlo con Ansible. Debe instalar el complemento "Publicar a través de SSH" para integrar Jenkins con la instancia del servidor virtual EC2 donde está instalado Ansible y con otras instancias del servidor virtual EC2 donde está instalado Kubernetes .

Vaya a "Panel de control" → " Administrar Jenkins" → "Configurar sistema" → "Complementos disponibles" .

Luego ingrese "Publicar a través de SSH" en el cuadro de búsqueda.

Haga clic en el botón "Instalar sin reiniciar" . Espere a que finalice el proceso de descarga.

Paso 8: Configurar el complemento "Publicar a través de SSH" de Jenkins

Para hacerlo, siga estos pasos:

Vaya a "Panel de control" → "Administrar Jenkins" → "Configurar sistema" → "Publicar a través de SSH" .

Luego haga clic en los botones "Aplicar" y "Guardar" .

Aquí ha terminado de configurar el complemento Jenkins "Publicar a través de SSH" .

Paso 9: cree un nuevo directorio Docker en AnsibleServer

Vaya a la carpeta "/opt" en la instancia AnsibleServer EC2.

 cd /opt

Cree una nueva carpeta "docker" allí.

 sudo mkdir docker

Otorgue privilegios a esta carpeta "docker" .

 sudo chown ansible-admin:ansible-admin docker

Ahora, verifique los privilegios de la carpeta "docker" ejecutando este comando.

 ll

Puede ver que se puede acceder a la carpeta "docker" con el usuario "ansible-admin" .

Paso 10: Integre el complemento Github “Publicar a través de SSH” en el proceso

Ahora que el complemento Github "Publicar a través de SSH" está instalado y configurado, ahora puede integrarlo en la canalización que creó en el "[módulo 2]: Servidor Jenkins" para transferir un artefacto jar del proyecto desde " JenkinsServer" a “Servidor Ansible” .

Bueno, para integrar el complemento Github "Publicar a través de SSH" en el proceso, debes seguir estos pasos:

1. Navegue hasta "Panel de control" → "CI_CD_Pipeline" → "Configurar" → "Acciones posteriores a la compilación".
2. Haga clic en el botón "Agregar acción posterior a la compilación" .
3. Elija la opción "Enviar artefactos de compilación a través de SSH" .
4. Agregue "AnsibleServer" a la entrada "Nombre" en la sección "Servidor SSH" **.**
5. Agregue “target/*.jar” a la entrada “Archivos fuente” en la sección “Conjunto de transferencia” **.**
6. Agregue "destino/" a la entrada "Eliminar prefijo" en la sección "Conjunto de transferencia" **.**
7. Agregue “//opt/docker/” a la entrada “Directorio remoto” en la sección “Conjunto de transferencia” **.**
8. Por ahora, simplemente coloque una cadena vacía en la entrada 'Comando ejecutivo' en la sección 'Conjunto de transferencia'.

Finalmente, debe hacer clic en los botones "Aplicar" y "Guardar" para finalizar la integración del complemento "Publicar a través de SSH" con la canalización.

Paso 11: Pruebe el complemento Github "Publicar a través de SSH" integrado en la canalización

Ahora puede usar su canalización actualizada para transferir un artefacto jar del proyecto de " JenkinsServer" a "AnsibleServer" . Para hacerlo, debe hacer clic en el botón "Construir ahora" . Como resultado, verá un resultado de trabajo exitoso en el historial de compilación.

Si abre su terminal AWS EC2 “AnsibleServer” . Puedes comprobar que la tubería funciona bien.

 cd /opt/docker

Paso 12: configurar hosts Ansible

1. Especifique hosts directamente en el libro de estrategias: en su libro de estrategias, puede configurar el parámetro hosts en una lista de direcciones IP o nombres de host.
2. Utilice un archivo de inventario: Ansible le permite definir una lista de hosts en un archivo de inventario y hacer referencia a este archivo cuando ejecute su libro de estrategias. El archivo de inventario predeterminado es /etc/ansible/hosts .

Al editar /etc/ansible/hosts , puede administrar fácilmente grupos de hosts sin tener que escribir sus direcciones IP cada vez que ejecuta un libro de estrategias.

 sudo ifconfig 

 sudo vi /etc/ansible/hosts

Paso 13: Configurar la autenticación SSH sin contraseña en localhost para Ansible

 sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

 sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected] 

Ahora puede ver "Número de claves agregadas: 1" . Significa que la instalación de autenticación SSH sin contraseña se completó con éxito.

Paso 14: cree un nuevo libro de estrategias de Ansible para las tareas de Docker

1. Comience creando un nuevo archivo de libro de estrategias de Ansible. Simplemente use este comando.

 touch hello-app.yml

2. Luego, edite el archivo hello-app.yml recién creado. Ábrelo para editarlo con este comando.

 vi hello-app.yml

3. Dentro del archivo, escriba lo siguiente.

 --- - hosts: ansible user: root tasks: - name: create docker image command: docker build -t hello:latest . args: chdir: /opt/docker - name: create tag to push image onto dockerhub command: docker tag hello:latest zufarexplainedit/hello:latest - name: push docker image onto dockerhub command: docker push zufarexplainedit/hello:latest

Paso 13: Pruebe el manual de Ansible con tareas de Docker

 cd /opt/docker

 sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml

Paso 14: Integre las tareas de Ansible Docker en la canalización

Ahora que el complemento Github "Publicar a través de SSH" , Ansible y Docker están instalados y configurados, ahora puede integrarlos todos en la canalización que creó en el "[módulo 2]: Servidor Jenkins" para transferir un artefacto jar del proyecto. de " JenkinsServer" a "AnsibleServer" y luego cree una nueva imagen de Docker a partir de su proyecto y luego inserte esta imagen de Docker en Dockerhub.

Para lograrlo es necesario seguir estos pasos:

1. Navegue hasta "Panel de control" → "CI_CD_Pipeline" → "Configurar" → "Acciones posteriores a la compilación" → "Enviar artefactos de compilación a través de SSH".
2. Agregue el comando "sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml" a la entrada "Comando ejecutivo" .

Finalmente, haga clic en los botones "Aplicar" y "Guardar" para finalizar las tareas de integración de Ansible Docker con la canalización.

Paso 15: Pruebe el “libro de estrategias de Ansible con tareas de Docker ” integrado en la canalización

Ahora puede probar su canalización actualizada para transferir sin problemas un artefacto jar del proyecto desde " JenkinsServer" a "AnsibleServer", luego crear una nueva imagen de Docker a partir de su proyecto y luego enviar esta imagen de Docker a Dockerhub. Para hacerlo, debe hacer clic en el botón "Construir ahora" . Como resultado, verá un resultado de trabajo exitoso en el historial de compilación.

[Módulo 7]: Kubernetes

Ahora configuremos K8 en la instancia EC2. Creará una nueva instancia EC2 e instalará su herramienta de línea de comandos kubectl para interactuar más con un clúster de Kubernetes .

Paso 1: lanzar una instancia del servidor virtual AWS EC2

Utilice las instrucciones de la sección " Iniciar una instancia de servidor virtual AWS EC2" de este tutorial para finalizar este paso.

Paso 2: Conéctese a una instancia del servidor virtual AWS EC2

Paso 3: cambiar el nombre de host de la instancia del servidor virtual AWS EC2 “KubernetesServer”

 sudo vi /etc/hostname

Reemplace este nombre de host con "kubernetes-server" y luego reinícielo.

 sudo init 6

Paso 4: verifique la versión de AWS CLI

Utilice este comando para comprobar la versión de AWS .

 aws --version

Si puede ver la versión aws-cli/1.18 , debe descargar la última versión.

Paso 5: actualice la CLI de AWS

Copie y pegue el comando curl .

 curl "//awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

 unzip awscliv2.zip

 sudo ./aws/install

 aws --version

Paso 6: instalar kubectl

Ahora necesita instalar la herramienta de línea de comandos kubectl para interactuar más con un clúster de Kubernetes. Para eso, debe ir a AWS → Documentación → Amazon EKS → Guía del usuario → Instalación o actualización de kubectl → Linux .

 curl -O //s3.us-west-2.amazonaws.com/amazon-eks/1.27.1/2023-04-19/bin/linux/amd64/kubectl

 chmod +x kubectl

 sudo mv kubectl /usr/local/bin

 kubectl version --output=yaml

Paso 7: instale eksctl

 curl --silent --location "//github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp

 sudo mv /tmp/eksctl /usr/local/bin

 eksctl version

Paso 8: Crear función de IAM para eksctl

Debe crear una función de IAM y adjuntarla a su instancia EC2 "KubernetesServer" .

Vaya a Panel de IAM → Roles .

Haga clic en el botón "Crear rol" en la página web de roles de IAM .

Luego elija "servicio AWS", "EC2". Y haga clic en el botón "Siguiente" .

Luego, busque "AmazonEC2FullAccess" , "AmazonEC2FullAccess" , "IAMFullAccess" , "AWSCloudFormationFullAccess" en el cuadro de búsqueda y luego haga clic en el botón "Agregar permisos" .

Y luego haga clic en el botón "Siguiente" .

Luego escriba "Eksctl_Role" en la entrada "Nombre de rol" .

Y haga clic en el botón "Crear rol" .

Paso 9: conecte el rol de IAM con eksctl

Vaya a la página web de la instancia AWS EC2. Elija "Servidor Kuberbetes". Luego haga clic en "Acciones" → "Seguridad" → "Modificar función de IAM".

Elija "Eksctl_Role" y luego haga clic en el botón "Actualizar función de IAM" .

Ahora su rol de IAM está conectado con su “EKS_Server” y su herramienta eksctl.

Paso 10: crear un clúster eksctl

Para lograr esto, siga estos pasos:

1. Modifique el siguiente comando con su información específica.

 eksctl create cluster --name cluster-name \ --region region-name \ --node-type instance-type \ --nodes-min 2 \ --nodes-max 2 \ --zones <AZ-1>,<AZ-2>

 eksctl create cluster --name zufarexplainedit \ --region eu-north-1 \ --node-type t3.micro

2. Ejecute el comando modificado y espere pacientemente hasta que se complete el proceso de creación del clúster. Notará que el estado del clúster EKS se indica como "creando" en la página web de AWS CloudFormation.

   
   

Además, puede verificar el estado de creación exitosa del clúster EKS en la página web de AWS CloudFormation.

Paso 11: Crear el archivo yaml de implementación de Kubernetes

 touch hello-app-deployment.yaml

 vi hello-app-deployment.yaml

 apiVersion: apps/v1 kind: Deployment metadata: name: zufarexplainedit-hello-app labels: app: hello-app spec: replicas: 2 selector: matchLabels: app: hello-app template: metadata: labels: app: hello-app spec: containers: - name: hello-app image: zufarexplainedit/hello imagePullPolicy: Always ports: - containerPort: 8080 strategy: type: RollingUpdate rollingUpdate: maxSurge: 1 maxUnavailable: 1

Paso 12: cree el archivo yaml del servicio Kubernetes

 touch hello-app-service.yaml

 vi hello-app-service.yaml

 apiVersion: v1 kind: Service metadata: name: zufarexplainedit-hello-app-service labels: app: hello-app spec: selector: app: hello-app ports: - port: 8080 targetPort: 8080 type: LoadBalancer

Paso 13: Pruebe el clúster de Kubernetes usando kubectl

1. Aplicar implementación.

   Utilice el siguiente comando para aplicar la configuración de implementación.

 kubectl apply -f hello-app-deployment.yaml

2. Aplicar Servicio.

 kubectl apply -f hello-app-service.yaml

3. Verifique el estado del LoadBalancer.

   Supervise el estado de su servicio utilizando.

 kubectl get service zufarexplainedit-hello-app-service

4. Accede a tu aplicación.

   Usando un navegador web, ingrese la dirección IP externa asignada seguida de :8080. Después de un breve momento, la página se cargará y mostrará el mensaje "HelloWorld". Tenga en cuenta que la carga inicial puede tardar unos segundos.

   
   

   

   
   

 kubectl delete deployments --all

 kubectl delete pods --all

 kubectl delete services --all

 eksctl delete cluster --name {your cluster name} --region {your region name}

 eksctl delete cluster --name zufarexplainedit --region eu-north-1

Paso 14: Agregar y configurar un nuevo usuario en la instancia del servidor virtual AWS EC2 “KubernetesServer”

Ahora agreguemos un nuevo usuario ansible-admin a la instancia del servidor virtual AWS EC2 “KubernetesServer” .

 sudo useradd ansible-admin

Luego, configure la contraseña para el usuario ansible-admin .

 sudo passwd ansible-admin

Además, debe configurar los privilegios de usuario editando el archivo sudoers .

 sudo visudo

Agregue "ansible-admin ALL=(ALL) ALL" a este archivo sudoers .

Además, debe editar el archivo /etc/ssh/sshd_config para habilitar la autenticación de contraseña.

 sudo vi /etc/ssh/sshd_config 

 sudo service sshd reload

 sudo su - ansible-admin

Paso 15: Generar clave en una instancia de servidor virtual AWS EC2

Más adelante en este artículo, planea administrar servidores remotos, como la instancia del servidor virtual EC2 de K8 . Por eso es necesario configurar claves SSH.

 ssh-keygen

Paso 16: Configurar la autenticación SSH sin contraseña en localhost para Ansible

 sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

 sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected] 

Ahora puede ver "Número de claves agregadas: 1" . Significa que la instalación de autenticación SSH sin contraseña se completó con éxito.

Paso 17: Configurar hosts Ansible en la instancia AnsibleServer EC2

Cuando ejecuta un libro de estrategias de Ansible, especifica los hosts en los que debe ejecutarse. En este paso, debe especificar el host de la instancia EC2 de KubernetesServer. Para hacerlo, debe repetir los mismos pasos que pasó en " [Módulo 6]: Ansible".

 sudo ifconfig 

 sudo vi /etc/ansible/hosts 

Paso 18: cree un nuevo manual de Ansible para las tareas de Kubernetes

1. Comience creando un nuevo archivo de libro de estrategias de Ansible. Simplemente use este comando.

 touch kubernetes-hello-app.yml

2. Luego, edite el archivo hello-app.yml recién creado. Ábrelo para editarlo con este comando.

 vi kubernetes-hello-app.yml

3. Dentro del archivo, escriba lo siguiente:

 --- - hosts: kubernetes tasks: - name: deploy regapp on kubernetes command: kubectl apply -f hello-app-deployment.yaml - name: create service for regapp command: kubectl apply -f hello-app-service.yaml - name: update deployment with new pods if image updated in docker hub command: kubectl rollout restart deployment.apps/zufarexplainedit-hello-app

Paso 19: Integre un nuevo manual de Ansible para tareas de Kubernetes con Jenkins

1. Vaya a JenkinsServer → Panel de Jenkins → Nuevo elemento.
2. Cree un nuevo proyecto Jenkins Freestyle con el nombre "CD-Job".

   
   

   

   
   

3. Haga clic en el botón "Aceptar".
4. Vaya a la sección "Acciones posteriores a la compilación".
5. Haga clic en el botón "Agregar acción posterior a la compilación".
6. Elija la opción "Enviar artefactos de compilación a través de SSH".
7. Elija "AnsibleServer" como servidor SSH.
8. Agregue este comando a la entrada "comando ejecutivo".

   
   

 sudo -u ansible-admin ansible-playbook /opt/docker/kubernetes-hello-app.yml

9. Haga clic en los botones "Aplicar" y "Guardar".
10. Vaya al panel de Jenkins → “CI_CD_Pipeline” → Configurar → sección “Acciones posteriores a la compilación”.
11. Haga clic en el botón "Agregar acción posterior a la compilación".
12. Elija la opción "Crear otros proyectos".
13. Vaya a la sección "Crear otros proyectos".
14. Elija la opción "Activar solo si la compilación es estable".
15. Agregue "CD-Job" a la entrada "Proyecto para construir".

    
    

    
    

    

    
    

16. Haga clic en los botones "Aplicar" y "Guardar".

    
    

Paso 20: Probar la versión final del canal

Conclusión

Sobre el Autor

Zufar Sunagatov es un experimentado ingeniero de software senior apasionado por el diseño de sistemas de software modernos.

• Desarrollé sistemas distribuidos de alto rendimiento utilizando Java, Kotlin, AWS, Docker y Kubernetes para empresas como Citi (Londres), MTS (Moscú) y otras ( ).
• Fundó Ice Latte, un mercado en línea de código abierto desde cero (puede unirse al equipo de Zufar y contribuir a su proyecto en GitHub: ).
• Estableció la comunidad ZufarExplainedIT para compartir su conocimiento y experiencia con otros (puede seguir la comunidad IT Telegram de Zufar: ).
• Fue asesorado durante más de 3000 minutos y realizó 60 sesiones en ADPlist, fomentando talentos aspirantes ( ).
• Atrajo al público como orador en conferencias y canales de YouTube de TI, compartiendo ideas invaluables (ejemplos de sus videos de YouTube incluyen: , ).
• Es autor de artículos de TI muy populares con más de 7000 visitas cada uno (ejemplos de sus artículos son: “Patrones de arquitectura de microservicios Parte 1: Patrones de descomposición” , ).