Ricerca nel sito web

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


Su questa pagina

  1. Prerequisiti
  2. Cosa faremo
  3. Scrivi file di configurazione Terraform per creare un VPC con altre risorse dipendenti.
  4. Crea un VPC e altre risorse dipendenti utilizzando i file di configurazione Terraform
  5. Elimina il VPC creato e altre risorse dipendenti utilizzando Terraform
  6. Conclusione

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 apprendere il VPC e la sua creazione dalla console AWS, puoi fare clic qui e per apprendere le nozioni di base 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 (crealo 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 e secret_key su AWS, )

Cosa faremo

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

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

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

Utilizzare il seguente comando 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 di tua scelta e copiare e incollare le seguenti configurazioni per creare variable.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 variable.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 variable.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 precedente. Abbiamo conservato la dichiarazione di queste due variabili nel file terraform.tfvars.

Le seguenti chiavi devono essere modificate con le chiavi dell'utente IAM.

vim terraform.tfvars
access_key = "AKIAQ6GAIA5XIHHM2GJM"
secret_key = "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"

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

Crea un VPC e altre risorse dipendenti utilizzando i file di configurazione 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 all'interno della configurazione. Nel nostro caso, è AWS.

terraform init

Il secondo comando da utilizzare è terraform plan. Questo comando viene utilizzato per vedere i cambiamenti 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 contributo per creare le risorse.

terraform apply

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

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

Elimina il VPC creato e le altre risorse dipendenti utilizzando 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 verificarlo 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 create possono essere distrutte.