Jenkins en EC2: implementación automatizada usando Terraform

DevOps

Configurar Jenkins en AWS puede ser un proceso tedioso y propenso a errores. Utilice Terraform para instalar Jenkins automáticamente en instancias AWS EC2.



comunidad LHB

Jenkins es un popular servidor de automatización de código abierto que se puede utilizar para implementar canales de integración y entrega continua para proyectos de software. Le permite crear, probar e implementar código utilizando un conjunto de instrucciones llamado Jenkinsfile.

Sin embargo, instalar y configurar Jenkins en plataformas en la nube como AWS puede ser un proceso tedioso y propenso a errores. Entonces, en este artículo, le mostraré cómo automatizar la instalación de Jenkins en una instancia AWS EC2 usando Terraform, una herramienta de infraestructura como código que le permite crear y administrar recursos en la nube de forma declarativa.

Al utilizar terraform, puede simplificar y estandarizar la implementación de Jenkins en AWS y aprovechar el control de versiones, la modularidad y la reutilización de su código de infraestructura.

requisitos previos

Deberá cumplir con los siguientes requisitos previos:

  • Una cuenta de AWS con permisos para crear instancias EC2 y otros recursos.Puede registrarse para obtener una cuenta de nivel gratuito en el sitio web de AWS
  • Terraform está instalado en su máquina local. Puede descargar el paquete apropiado para su sistema operativo desde la página de descarga de Terraform y seguir las instrucciones de instalación, o usar un administrador de paquetes como Homebrew en Mac OS o Chocolatey en Windows.
  • Configure la AWS CLI en su computadora local utilizando sus credenciales y región de AWS. Puede seguir la documentación oficial para instalar AWS CLI.

Una vez que tenga todos los requisitos previos implementados, puede continuar con la siguiente sección, configurar Jenkins usando Terraform en una instancia AWS EC2.

Paso 1: crear el directorio utilizado por el proyecto

El primer paso es crear el directorio que se utilizará para este proyecto, comencemos con variable.tf documento:

variable "ami" {
  type    = string
  default = "#AMI_OF_UBUNTU"
}

variable "infra_env" {
  default = "YOUR_ENV"
}

variable "instace_type" {
  type    = string
  default = "t3.medium"
}

variable "keyname" {
  type    = string
  default = "YOUR_KEY_NAME"
}

variable "vpc_cidr" {
  type    = string
  default = "VPC_CIDR"
}

variable "public_subnets" {
  type    = list(any)
  default = ["subnet-XX1", "subnet-XX2", "subnet-XX3"]
}

variable "private_subnets" {
  type    = list(any)
  default = ["subnet-XX1", "subnet-XX2", "subnet-XX3"]
}

variable "azs" {
  type    = list(any)
  default = ["eu-central-1a", "eu-central-1b", "eu-central-1c"]
}

variable "vpc_id" {
  type    = string
  default = "vpc-XX"
}

variable "alb_sg" {
  default = "sg-XX"
}

variable "instance_name" {
  default = "jenkins"
}

El archivo Variables.tf es donde define las variables de entrada para su configuración de terraform. Estas variables le permiten personalizar y reutilizar su código para diferentes entornos y escenarios. Aquí hay una breve descripción de cada variable en el archivo:

  • ami: esta variable especifica el ID de imagen de máquina de Amazon (AMI) que desea utilizar para la instancia EC2. Puede encontrar el ID de AMI de Ubuntu en: [AWS Marketplace] o usar [aws_ami data source] Obtenga dinámicamente la última ID de AMI.
  • infra_env: esta variable define el nombre de su entorno de infraestructura, como dev, test o prod. Puede utilizar esta variable para etiquetar sus recursos y distinguirlos de otros entornos.
  • instance_type: Esta variable determina el tipo de instancia EC2 que desea lanzar. Puede elegir entre una variedad de tipos de instancias que ofrecen diferentes combinaciones de CPU, memoria, almacenamiento y capacidad de red.Puede encontrar más información sobre los tipos de instancia en [AWS documentation].
  • keyname: esta variable especifica el nombre del par de claves que desea utilizar para acceder a la instancia EC2 a través de SSH.Puede [AWS console] o usar [aws_key_pair resource] Utilice terraform para generar uno.
  • vpc_cidr: Esta variable define el bloque CIDR de una nube privada virtual (VPC), que es una red lógica que aísla sus recursos de AWS de la Internet pública. Puede utilizar cualquier bloque CIDR IPv4 válido que no se superponga con otras redes en su cuenta o región.
  • public_subnets: esta variable es una lista de ID de subred que están asociados con su VPC y tienen rutas a la puerta de enlace de Internet. Estas subredes permiten que sus instancias EC2 se comuniquen con Internet y reciban tráfico del Balanceador de carga de aplicaciones (ALB).
  • private_subnets: esta variable es una lista de ID de subred asociados con su VPC que no tienen una ruta a una puerta de enlace de Internet. Estas subredes se utilizan para la comunicación interna entre instancias EC2 y otros servicios de AWS, como RDS o S3.
  • azs: esta variable es una lista de zonas de disponibilidad (AZ) en su región que admiten el tipo de instancia que seleccionó. Las zonas de disponibilidad son ubicaciones físicamente aisladas que brindan alta disponibilidad y tolerancia a fallas para sus recursos.puedes usarlo [aws_availability_zones data source] Obtenga una lista de todas las zonas de disponibilidad en su región.
  • vpc_id: esta variable especifica el ID de su VPC.puedes usarlo [aws_vpc data source] Obtenga el ID de una VPC existente o utilice [aws_vpc resource] Crea uno nuevo usando terraform.
  • alb_sg: esta variable especifica el ID del grupo de seguridad adjunto al ALB. Un grupo de seguridad es un conjunto de reglas que controlan el tráfico entrante y saliente a un recurso.puedes usarlo [aws_security_group data source] Obtenga la identificación de un grupo de seguridad existente o use [aws_security_group resource] Crea uno nuevo usando terraform.
  • instance_name: Esta variable define el nombre de su instancia EC2. Puede utilizar esta variable para etiquetar su instancia e identificarla fácilmente en la consola o CLI de AWS.

Paso 2: crear un archivo de grupo de seguridad

El segundo paso es crear grupodeseguridad.tf archivo que define el grupo de seguridad para su instancia EC2. Un grupo de seguridad es un conjunto de reglas que controlan el tráfico entrante y saliente a un recurso.

resource "aws_security_group" "jenkins_sg" {
  name        = "${var.instance_name}-sg"
  description = "Needed rules."

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port       = 8080
    to_port         = 8080
    protocol        = "tcp"
    cidr_blocks     = ["0.0.0.0/0"]
    security_groups = ["sg-XX"]
    self            = true
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  vpc_id = var.vpc_id

  tags = {
    Name = "${var.instance_name}-SG"
  }
}

Aquí hay una breve descripción de cada bloque en el archivo:

  • resource "aws_security_group" "jenkins_sg": Este bloque crea un nuevo recurso de grupo de seguridad llamado ${var.instance_name}-sg y descripción Needed rules.. El nombre y la descripción son opcionales, pero le ayudan a identificar fácilmente el recurso.este jenkins_sg es un nombre local que puede utilizar para hacer referencia a este recurso en otras partes de la configuración.
  • ingress: este bloque especifica reglas para el tráfico entrante a la instancia EC2. Puede configurar múltiples bloques de entrada para diferentes tipos de tráfico. En este ejemplo, tiene dos bloques de entrada:
  • El primero permite el acceso SSH (puerto 22) desde cualquier dirección IP (0.0.0.0/0) utilizando el protocolo TCP. Esto es útil para depurar y solucionar problemas, pero por razones de seguridad es posible que desee restringir el acceso a rangos de IP o grupos de seguridad específicos.
  • El segundo permite el acceso HTTP (puerto 8080) desde cualquier dirección IP (0.0.0.0/0) o grupo de seguridad con ID. sg-XX Utilice el protocolo TCP.este self La propiedad se establece en verdadero, lo que significa que la regla también se aplica al tráfico dentro del mismo grupo de seguridad. Esto es necesario para que ALB se comunique con su instancia EC2.
  • egress: este bloque especifica reglas para el tráfico saliente de instancias EC2. Puede configurar múltiples bloques de salida para diferentes tipos de tráfico. En este ejemplo, tiene un bloque de salida que permite todo el tráfico (puerto 0) utilizando cualquier protocolo (-1) hacia cualquier dirección IP (0.0.0.0/0). Esto significa que su instancia EC2 puede acceder a cualquier servicio o recurso externo en Internet o dentro de su VPC.
  • vpc_id: este atributo establece el ID de la VPC a la que pertenece su grupo de seguridad.Puedes usar variables. var.vpc_id Lo defines en el archivo variables.tf.
  • tags: este bloque le permite agregar pares clave-valor de metadatos a un recurso de grupo de seguridad. Las etiquetas son útiles para organizar, filtrar y buscar recursos en la consola o CLI de AWS.En este ejemplo tienes una etiqueta con una clave. Name y valor ${var.instance_name}-SG.

Paso 3: crear un script bash de datos de usuario

En este paso, definirá el script de datos de usuario que se ejecutará cuando se aplique Terraform.vamos a crear datos de usuario.sh documento:

#!/bin/bash
#########################################################################
## Description: Automate the installation of Jenkins as container.
## Author: Omar XS [Github]
## Date: Sep 2nd 2023
#########################################################################

## Update && upgrade && install docker
apt update
apt -y upgrade
apt update
apt -y install docker.io docker-compose
usermod -aG docker ubuntu

cat > /home/ubuntu/docker-compose.yaml << EOF
version: '2'
services:
  jenkins:
    image: jenkins/jenkins:lts
    privileged: true
    user: root
    ports:
      - 8080:8080
      - 50000:50000
    container_name: jenkins
    volumes:
      - ./jenkins_compose/jenkins_configuration:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

EOF

#! START_JENKINS !#
docker-compose -f /home/ubuntu/docker-compose.yaml up -d

este datos de usuario.sh script es un script bash que instala automáticamente Jenkins como contenedor en una instancia EC2. Primero actualiza y mejora los paquetes del sistema, luego instala Docker y Docker-compose. Luego crea un archivo Docker-Compose que define el servicio Jenkins con las opciones de configuración necesarias, como puertos, volúmenes y permisos. Finalmente, ejecuta el comando docker-compose para iniciar el contenedor Jenkins en segundo plano.

Paso 4: crea el archivo principal de terraform

El último paso es crear el archivo main.tf, que define la configuración principal de terraform del proyecto. Este archivo creará una instancia EC2 con una IP elástica que se puede usar para acceder a la interfaz web de Jenkins.

provider "aws" {
  region = "eu-central-1"
  default_tags {
    tags = {
      Terraform   = "true"
      Environment = "${var.infra_env}"
    }
  }
}

resource "aws_instance" "jenkins" {
  ami           = var.ami # Ubuntu
  instance_type = var.instace_type
  key_name      = var.keyname
  root_block_device {
    volume_size = 25
  }

  vpc_security_group_ids = ["${aws_security_group.jenkins_sg.id}", "${var.alb_sg}"]
  subnet_id              = var.public_subnets[0]

  tags = {
    Name = "${var.instance_name}"
  }

  user_data = file("userdata.sh")
}

resource "aws_eip" "jenkins_elasticIP" {
  vpc = true

  instance = aws_instance.jenkins.id
  tags = {
    Name = "${var.instance_name}-ElasticIP"
  }
}

output "jenkins_static_ip" {
  value = aws_eip.jenkins_elasticIP.public_ip
}


output "msg" {
  value = "Please wait 5-10 mintues until ${var.instance_name} is up and running."
  depends_on = [
    aws_instance.jenkins
  ]
}

El archivo main.tf utiliza terraform para crear una instancia EC2 con una IP elástica.Utiliza un proveedor de AWS con regiones. eu-central-1 y variables en el archivo Variables.tf. También utiliza grupos de seguridad del archivo security-group.tf y scripts de datos de usuario del archivo userdata.sh. Genera la IP estática de la instancia y un mensaje esperando a que Jenkins esté listo.

en conclusión

En este artículo, aprendió a utilizar terraform para automatizar la instalación de Jenkins en una instancia AWS EC2.

Ha creado un proyecto de Terraform que contiene cuatro archivos: variables.tf, security-group.tf, userdata.sh y main.tf. También compartí estos archivos en mi repositorio de GitHub.

jenkins-ec2-automated, usa Terraform para crear automáticamente instancias EC2 e instalar Jenkins en ellas, descargue el código fuente de jenkins-ec2-automated_GitHub_Bangku

Utilice Terraform para crear automáticamente una instancia EC2 e instalar Jenkins en ella. jenkins-ec2-automated, usa Terraform para crear automáticamente instancias EC2 e instalar Jenkins en ellas, descargue el código fuente de jenkins-ec2-automated_GitHub_Bangku

Ha utilizado variables para personalizar nuestra configuración, ha utilizado grupos de seguridad para controlar el tráfico a la instancia, ha utilizado scripts de datos de usuario para instalar Jenkins como contenedor utilizando Docker y Docker-compose, y ha utilizado archivos maestros para crear instancias EC2 e IP elásticas. También aprendió cómo acceder a la interfaz web de Jenkins utilizando una IP estática y el puerto 8080.

Sin embargo, el uso de HTTP no es seguro y deja nuestro servidor Jenkins expuesto a posibles ataques. Por lo tanto, debes utilizar HTTPS para cifrar las comunicaciones entre nuestro navegador y nuestros servidores. Hay dos maneras de lograr esto:

  • Un enfoque es utilizar un balanceador de carga de aplicaciones (ALB) frente a la instancia EC2 y configurarlo para usar HTTPS con un certificado de AWS Certificate Manager (ACM). De esta manera, ALB manejará la terminación SSL y reenviará el tráfico a nuestra instancia mediante HTTP.
  • Otro enfoque es instalar nginx en la misma instancia EC2 y usarlo como proxy inverso para enrutar el tráfico a Jenkins. También necesitarás usar certbot para obtener un certificado gratuito de Let’s Encrypt y configurar nginx para usar HTTPS. De esta manera, nginx manejará la terminación SSL y reenviará el tráfico a Jenkins mediante HTTP.

Espero que este tutorial te haya resultado útil.

📋

Este artículo fue contribuido por Omar. Es un ingeniero de DevOps que maneja muchos temas relacionados con Docker, servidores, servicios en la nube, Kubernetes y más. Su objetivo es ahorrar tiempo a las personas impartiéndoles conocimientos que a él le habría llevado minutos, horas, días o incluso semanas descubrir.
Qué significan <,<< y <<<
<, << y <<< parecen similares a los indicadores de redireccionamiento, pero tienen propósitos diferentes. Conócelos. ¿No parecen indicadores de ...
Usando el comando bc en scripts de Linux y Bash
El comando bc en Linux se utiliza para cálculos matemáticos. Esto no es sólo una orden; es un lenguaje. Pero ...
Usando bucles while en Bash
Aprenda a usar bucles while en bash con ejemplos prácticos en este tutorial. Al ejecutar scripts bash, a veces te ...
Buscar un directorio en Linux
Puede utilizar el comando buscar de varias formas para buscar un directorio con parámetros específicos. En Linux, crea varios archivos ...
Usando el bucle Hasta en Bash
Y para conocer quizás el bucle bash más popular, espere hasta descubrirlo. Retruécano:) Los bucles son la base de cualquier ...
Python agrega comentarios de varias líneas
Python no admite comentarios de varias líneas de forma predeterminada. Sin embargo, puede utilizar la funcionalidad docstring para lograrlo. Cuando ...
Ordenar la salida del comando por tamaño en Linux
El comando du se utiliza para ver el espacio utilizado por directorios y archivos en Linux. Esto significa que puede ...
Cómo ejecutar scripts de shell Bash desde la línea de comandos de Linux
Ejecutar un script de shell bash es muy simple. Pero en este tutorial, también puedes aprender cómo ejecutarlos en un ...
Cómo enumerar dispositivos USB en Linux
¿Quiere identificar los dispositivos USB conectados a su sistema? A continuación se muestran varias formas de enumerar dispositivos USB en ...
Cómo extraer y crear archivos RAR en Linux
¿Existe un archivo RAR? Aprenda a extraer archivos rar desde la línea de comandos de Linux. También puedes aprender a ...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para fines de afiliación y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Contiene enlaces a sitios web de terceros con políticas de privacidad ajenas que podrás aceptar o no cuando accedas a ellos. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad