Crea un Virtual Private Cloud (VPC) su AWS utilizzando Terraform

In questo articolo, ti mostrerò come creare un VPC insieme a sottoreti, gateway Internet, gateway NAT e tabelle di instradamento. Realizzeremo 1 VPC con 4 sottoreti:2 private e 2 pubbliche, 2 gateway NAT, 1 gateway Internet e 4 tabelle di instradamento.

Prima di procedere, presumo che tu abbia una conoscenza di base di Terraform e VPC su AWS. Per conoscere il VPC e la sua creazione dalla console AWS, puoi fare clic qui e per apprendere le basi di Terraform puoi cercare "Cos'è Terraform e come installarlo sull'istanza AWS EC2?"

Prerequisiti

1. Comprensione di base di Terraform.
2. Terraform installato sul tuo sistema.
3. Account AWS (crea se non ne hai uno).
4. 'access_key' e 'secret_key' di un utente AWS IAM. (Fai clic qui per imparare a creare un utente IAM con 'access_key' &'secret_key' su AWS, )

Cosa faremo

1. Scrivi i file di configurazione di Terraform per creare un VPC con altre risorse dipendenti.
2. Crea un VPC e altre risorse dipendenti utilizzando i file di configurazione di Terraform
3. Elimina il VPC creato e altre risorse dipendenti utilizzando Terraform

Scrivi i file di configurazione di Terraform per creare un VPC con altre risorse dipendenti.

Crea una directory dedicata in cui puoi creare file di configurazione di terraform.

Utilizzare il comando seguente per creare una directory e modificare la directory di lavoro attuale in essa.

mkdir terraform
cd terraform/

Sto usando "vim" come editor per scrivere nei file. Puoi utilizzare un editor a tua scelta e copiare e incollare le seguenti configurazioni per creare variabili.tf, terraform.tfvars e main.tf

Crea "main.tf", che è responsabile della creazione di VPC su AWS con le risorse dipendenti. Questo main.tf leggerà i valori delle variabili da variabili.tf e terraform.tfvars.

vim main.tf

provider "aws" {
      region     = "${var.region}"
      access_key = "${var.access_key}"
      secret_key = "${var.secret_key}"
}


# VPC resources: This will create 1 VPC with 4 Subnets, 1 Internet Gateway, 4 Route Tables. 

resource "aws_vpc" "default" {
  cidr_block           = var.cidr_block
  enable_dns_support   = true
  enable_dns_hostnames = true
}

resource "aws_internet_gateway" "default" {
  vpc_id = aws_vpc.default.id
}

resource "aws_route_table" "private" {
  count = length(var.private_subnet_cidr_blocks)

  vpc_id = aws_vpc.default.id
}

resource "aws_route" "private" {
  count = length(var.private_subnet_cidr_blocks)

  route_table_id         = aws_route_table.private[count.index].id
  destination_cidr_block = "0.0.0.0/0"
  nat_gateway_id         = aws_nat_gateway.default[count.index].id
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.default.id
}

resource "aws_route" "public" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.default.id
}

resource "aws_subnet" "private" {
  count = length(var.private_subnet_cidr_blocks)

  vpc_id            = aws_vpc.default.id
  cidr_block        = var.private_subnet_cidr_blocks[count.index]
  availability_zone = var.availability_zones[count.index]
}

resource "aws_subnet" "public" {
  count = length(var.public_subnet_cidr_blocks)

  vpc_id                  = aws_vpc.default.id
  cidr_block              = var.public_subnet_cidr_blocks[count.index]
  availability_zone       = var.availability_zones[count.index]
  map_public_ip_on_launch = true
}

resource "aws_route_table_association" "private" {
  count = length(var.private_subnet_cidr_blocks)

  subnet_id      = aws_subnet.private[count.index].id
  route_table_id = aws_route_table.private[count.index].id
}

resource "aws_route_table_association" "public" {
  count = length(var.public_subnet_cidr_blocks)

  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}


# NAT resources: This will create 2 NAT gateways in 2 Public Subnets for 2 different Private Subnets.

resource "aws_eip" "nat" {
  count = length(var.public_subnet_cidr_blocks)

  vpc = true
}

resource "aws_nat_gateway" "default" {
  depends_on = ["aws_internet_gateway.default"]

  count = length(var.public_subnet_cidr_blocks)

  allocation_id = aws_eip.nat[count.index].id
  subnet_id     = aws_subnet.public[count.index].id
}
 

Crea 'variables.tf' che contiene la dichiarazione e la definizione delle variabili.

vim variables.tf

variable "access_key" {
     description = "Access key to AWS console"
     
}
variable "secret_key" {
     description = "Secret key to AWS console"
     
}

variable "region" {
  default     = "eu-west-3"
  type        = string
  description = "Region of the VPC"
}


variable "cidr_block" {
  default     = "10.0.0.0/16"
  type        = string
  description = "CIDR block for the VPC"
}

variable "public_subnet_cidr_blocks" {
  default     = ["10.0.0.0/24", "10.0.2.0/24"]
  type        = list
  description = "List of public subnet CIDR blocks"
}

variable "private_subnet_cidr_blocks" {
  default     = ["10.0.1.0/24", "10.0.3.0/24"]
  type        = list
  description = "List of private subnet CIDR blocks"
}

variable "availability_zones" {
  default     = ["eu-west-3a", "eu-west-3b"]
  type        = list
  description = "List of availability zones"
}
 

Crea 'terraform.tfvars' che contiene la definizione delle variabili access_key e secret_key definite nel file sopra. Abbiamo conservato la dichiarazione di queste due variabili nel file 'terraform.tfvars'.

Le seguenti chiavi devono essere modificate con le chiavi del tuo utente IAM.

vim terraform.tfvars

access_key = "AKIAQ6GAIA5XIHHM2GJM"
secret_key = "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"

Ora dovresti avere 3 file, vale a dire, variabili.tf, terraform.tfvars e main.tf

Crea un VPC e altre risorse dipendenti utilizzando i file di configurazione di Terraform

Prima di eseguire i seguenti comandi, assicurati di aver configurato access_key e secret_key validi.

Il primo comando da utilizzare è 'terraform init'. Questo comando scarica e installa i plug-in per i provider utilizzati nella configurazione. Nel nostro caso, è AWS.

terraform init

Il secondo comando da utilizzare è 'terraform plan'. Questo comando viene utilizzato per vedere le modifiche che avverranno sull'infrastruttura.

terraform plan

Il comando 'terraform apply' creerà le risorse su AWS menzionate nel file main.tf. Ti verrà chiesto di fornire il tuo input per creare le risorse.

terraform apply

Quando esegui il comando precedente, puoi vedere che sono state aggiunte 20 nuove risorse e 0 è stato distrutto nell'output.

Puoi accedere alla console AWS VPC per verificare se il VPC è stato creato insieme a sottoreti, gateway NAT delle tabelle di instradamento e un gateway Internet.

Elimina il VPC creato e altre risorse dipendenti usando Terraform

Se non hai più bisogno delle risorse che hai creato utilizzando la configurazione menzionata nel file main.tf, puoi utilizzare il comando "terraform destroy" per eliminare tutte quelle risorse.

terraform destroy

Quando esegui il comando precedente, puoi vedere che 20 risorse che sono state create vengono distrutte nell'output. Puoi verificare lo stesso visitando AWS nella dashboard VPC.

Conclusione

In questo articolo, abbiamo visto i passaggi per creare un VPC con 4 sottoreti, 4 tabelle di instradamento, 2 gateway NAT e 1 gateway Internet. Abbiamo anche visto come le risorse che sono state create possono essere distrutte.