El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Proyecto 1: Infraestructura AWS

Siguiente ►
►

En este proyecto, vamos a aplicar los conocimientos adquiridos a lo largo del curso para crear y gestionar una infraestructura en AWS utilizando Terraform. Este proyecto está diseñado para consolidar tus habilidades y darte una experiencia práctica en un entorno del mundo real.

Objetivos del Proyecto

  1. Configurar un proveedor de AWS en Terraform.
  2. Crear una VPC (Virtual Private Cloud).
  3. Configurar subredes públicas y privadas.
  4. Implementar instancias de EC2 en las subredes.
  5. Configurar un balanceador de carga (ELB).
  6. Configurar reglas de seguridad (Security Groups).

Requisitos Previos

  • Cuenta de AWS activa.
  • Terraform instalado y configurado en tu máquina local.
  • Conocimientos básicos de AWS y Terraform.

Paso 1: Configurar el Proveedor de AWS

Primero, necesitamos configurar el proveedor de AWS en nuestro archivo de configuración de Terraform.

# provider.tf
provider "aws" {
  region = "us-west-2"
}

Explicación

  • provider "aws": Define el proveedor de AWS.
  • region: Especifica la región de AWS donde se desplegarán los recursos.

Paso 2: Crear una VPC

Vamos a crear una VPC con un bloque CIDR de 10.0.0.0/16.

# vpc.tf
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  tags = {
    Name = "main-vpc"
  }
}

Explicación

  • resource "aws_vpc" "main": Define un recurso de VPC en AWS.
  • cidr_block: Especifica el rango de direcciones IP para la VPC.
  • tags: Añade etiquetas para identificar la VPC.

Paso 3: Configurar Subredes Públicas y Privadas

Vamos a crear una subred pública y una privada dentro de la VPC.

# subnets.tf
resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  map_public_ip_on_launch = true
  availability_zone = "us-west-2a"
  tags = {
    Name = "public-subnet"
  }
}

resource "aws_subnet" "private" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.2.0/24"
  availability_zone = "us-west-2a"
  tags = {
    Name = "private-subnet"
  }
}

Explicación

  • vpc_id: Asocia la subred con la VPC creada anteriormente.
  • cidr_block: Define el rango de direcciones IP para la subred.
  • map_public_ip_on_launch: Asigna automáticamente una IP pública a las instancias en la subred pública.
  • availability_zone: Especifica la zona de disponibilidad.

Paso 4: Implementar Instancias de EC2

Vamos a crear una instancia de EC2 en la subred pública y otra en la subred privada.

# ec2.tf
resource "aws_instance" "public_instance" {
  ami           = "ami-0c55b159cbfafe1f0" # Amazon Linux 2 AMI
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.public.id
  tags = {
    Name = "public-instance"
  }
}

resource "aws_instance" "private_instance" {
  ami           = "ami-0c55b159cbfafe1f0" # Amazon Linux 2 AMI
  instance_type = "t2.micro"
  subnet_id     = aws_subnet.private.id
  tags = {
    Name = "private-instance"
  }
}

Explicación

  • ami: Especifica la Amazon Machine Image (AMI) para la instancia.
  • instance_type: Define el tipo de instancia.
  • subnet_id: Asocia la instancia con la subred correspondiente.

Paso 5: Configurar un Balanceador de Carga (ELB)

Vamos a configurar un balanceador de carga para distribuir el tráfico entre las instancias.

# elb.tf
resource "aws_elb" "web" {
  name               = "web-load-balancer"
  availability_zones = ["us-west-2a"]

  listener {
    instance_port     = 80
    instance_protocol = "HTTP"
    lb_port           = 80
    lb_protocol       = "HTTP"
  }

  instances = [aws_instance.public_instance.id]

  health_check {
    target              = "HTTP:80/"
    interval            = 30
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 2
  }

  tags = {
    Name = "web-load-balancer"
  }
}

Explicación

  • availability_zones: Define las zonas de disponibilidad donde el ELB estará activo.
  • listener: Configura el puerto y el protocolo para el balanceador de carga.
  • instances: Lista de instancias que el ELB balanceará.
  • health_check: Configura las verificaciones de salud para las instancias.

Paso 6: Configurar Reglas de Seguridad (Security Groups)

Vamos a crear grupos de seguridad para las instancias y el balanceador de carga.

# security_groups.tf
resource "aws_security_group" "web_sg" {
  vpc_id = aws_vpc.main.id

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

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

  tags = {
    Name = "web-sg"
  }
}

resource "aws_security_group" "private_sg" {
  vpc_id = aws_vpc.main.id

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

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

  tags = {
    Name = "private-sg"
  }
}

Explicación

  • ingress: Define las reglas de entrada para el grupo de seguridad.
  • egress: Define las reglas de salida para el grupo de seguridad.

Ejercicio Práctico

  1. Configura el proveedor de AWS en Terraform.
  2. Crea una VPC con un bloque CIDR de 10.0.0.0/16.
  3. Configura una subred pública y una privada.
  4. Implementa una instancia de EC2 en cada subred.
  5. Configura un balanceador de carga para la instancia pública.
  6. Crea grupos de seguridad para las instancias y el balanceador de carga.

Solución

La solución completa se encuentra en los archivos de configuración proporcionados anteriormente. Asegúrate de aplicar los cambios utilizando los comandos de Terraform:

terraform init
terraform plan
terraform apply

Conclusión

En este proyecto, hemos creado una infraestructura básica en AWS utilizando Terraform. Hemos configurado una VPC, subredes, instancias de EC2, un balanceador de carga y grupos de seguridad. Este ejercicio práctico te proporciona una base sólida para gestionar infraestructuras más complejas en el futuro.

En el siguiente proyecto, exploraremos cómo desplegar una infraestructura multi-nube utilizando Terraform. ¡Sigue adelante y sigue aprendiendo!

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados