Erstellen einer Virtual Private Cloud ( VPC) auf AWS mit Terraform

In diesem Artikel zeige ich Ihnen, wie Sie eine VPC zusammen mit Subnetzen, Internet-Gateway, NAT-Gateways und Route Tables erstellen. 1 VPC wird mit 4 Subnetzen erstellt: 2 private und 2 öffentliche, 2 NAT-Gateways, 1 Internet-Gateway und 4 Route Tables.

Bevor Sie fortfahren, gehe ich davon aus, dass Sie ein grundlegendes Verständnis von Terraform und VPC auf AWS haben. Um die VPC und ihre Erstellung von der AWS Konsole aus zu erlernen, können Sie hier klicken und um die Grundlagen von Terraform zu erfahren, können Sie nach „Was ist Terraform und wie installiert man es auf der AWS EC2 Instanz?

Vorraussetzungen

  1. Grundlegendes Verständnis von Terraform.
  2. Terraform auf Ihrem System installiert.
  3. AWS-Konto (Erstellen Sie, falls Sie keines haben).
  4. ‚access_key‘ & ’secret_key‘ eines AWS IAM-Benutzers. (Klicken Sie hier, um zu erfahren, wie man einen IAM-Benutzer mit ‚access_key‘ & ’secret_key‘ auf AWS erstellt, )

Was wir tun werden

  1. Schreiben von Terraform-Konfigurationsdateien zur Erstellung einer VPC mit anderen abhängigen Ressourcen.
  2. Erstellen Sie einen VPC und andere abhängige Ressourcen mit Hilfe der Terraform-Konfigurationsdateien
  3. Löschen Sie die erstellte VPC und andere abhängige Ressourcen mit Terraform

Schreiben Sie Terraform-Konfigurationsdateien zur Erstellung einer VPC mit anderen abhängigen Ressourcen.

Erstellen Sie ein dediziertes Verzeichnis, in dem Sie Terraform-Konfigurationsdateien erstellen können.

Verwenden Sie den folgenden Befehl, um ein Verzeichnis zu erstellen und Ihr gegenwärtiges Arbeitsverzeichnis in dieses zu ändern.

mkdir terraform
cd terraform/

Ich benutze „vim“ als Editor, um in Dateien zu schreiben. Sie können einen Editor Ihrer Wahl benutzen und die folgenden Konfigurationen kopieren und einfügen, um variables.tf, terraform.tfvars und main.tf zu erstellen

Erstellen Sie ‚main.tf‘, die für die Erstellung von VPC auf dem AWS mit den abhängigen Ressourcen verantwortlich ist. Diese main.tf wird Werte von Variablen aus variables.tf und terraform.tfvars lesen.

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
}
 

Erstellen Sie ‚variables.tf‘, die die Deklaration und Definition der Variablen enthält.

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"
}

Erstellen Sie ‚terraform.tfvars‘, die die Definition der in der obigen Datei definierten access_key und secret_key Variablen enthält. Wir haben die Deklaration dieser beiden Variablen in der Datei ‚terraform.tfvars‘ aufbewahrt.

Die folgenden Schlüssel müssen mit den Schlüsseln Ihres IAM-Benutzers geändert werden.

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

Nun sollten Sie 3 Dateien haben, nämlich variables.tf, terraform.tfvars und main.tf

Erstellen Sie ein VPC und andere abhängige Ressourcen mit Hilfe der Terraform-Konfigurationsdateien

Bevor Sie die folgenden Befehle ausführen, stellen Sie sicher, dass Sie den gültigen access_key und secret_key konfiguriert haben.

Der erste zu verwendende Befehl ist „terraform init“. Mit diesem Befehl werden Plugins für die in der Konfiguration verwendeten Provider heruntergeladen und installiert. In unserem Fall ist es AWS.

terraform init

Der zweite zu verwendende Befehl ist ‚terraform plan‘. Dieser Befehl wird verwendet, um die Änderungen zu sehen, die auf der Infrastruktur stattfinden werden.

terraform plan

Der Befehl ‚terraform apply‘ erstellt die Ressourcen auf dem AWS, die in der Datei main.tf erwähnt werden. Sie werden aufgefordert, Ihre Eingaben zur Erstellung der Ressourcen zu machen.

terraform apply

Wenn Sie den obigen Befehl ausführen, können Sie sehen, dass 20 neue Ressourcen hinzugefügt wurden und 0 in der Ausgabe zerstört wurde.

Sie können die AWS VPC-Konsole aufrufen, um zu überprüfen, ob die VPC zusammen mit Subnetzen, Routingtabellen, NAT-Gateways und einem Internet-Gateway erstellt wurde.

Löschen Sie die erstellte VPC und andere abhängige Ressourcen mit Terraform

Wenn Sie die Ressourcen, die Sie mit der in der Datei main.tf erwähnten Konfiguration erstellt haben, nicht mehr benötigen, können Sie den Befehl „terraform destroy“ verwenden, um alle diese Ressourcen zu löschen.

terraform destroy

Wenn Sie den obigen Befehl ausführen, können Sie sehen, dass 20 erzeugte Ressourcen in der Ausgabe zerstört werden. Sie können dies überprüfen, indem Sie AWS im VPC-Dashboard besuchen.

Schlussfolgerung

In diesem Artikel sahen wir die Schritte zur Erstellung einer VPC mit 4 Subnetzen, 4 Routingtabellen, 2 NAT-Gateways und 1 Internet-Gateway. Wir sahen auch, wie die geschaffenen Ressourcen zerstört werden können.

Das könnte Dich auch interessieren …