[LINUX] Erstellen Sie AWS EC2 und RDS mit Terraform Terraform 3 Minuten Garzeit

Einführung

Dieser Artikel beschreibt das Erstellen von AWS EC2 und RDS mit Terraform.

Die Ausführung mit "Terraform Apply" dauert ca. 3 Minuten. Es kann mit der Wartezeit von Cup Ramen gebaut werden.

Die folgende Umgebung (*) wird bereitgestellt. Darüber hinaus führt EC2 auch das minimale Betriebssystem-Setup durch.

Wenn Sie mit den Grundlagen von Terraform beginnen möchten, lesen Sie bitte den zuvor geschriebenen Der wahre Wert der Terraform-Automatisierung ab Oracle Cloud.

(*) Die in diesem Artikel beschriebene TF-Datei ist auf GitHub verfügbar.

Terraform-Konstruktion

Um mit Terraform in der AWS-Umgebung zu erstellen, erstellen Sie einen Benutzer mit IAM und bereiten Sie die erforderlichen Anmeldeinformationen vor. Installieren Sie anschließend Terraform und bereiten Sie die für die Ausführung von Terraform erforderliche tf-Datei vor.

Die Voraussetzungen für die AWS-Umgebung sind unten aufgeführt.

• [x] Benutzer mit IAM erstellen
• [x] Sie haben die erforderlichen Berechtigungen erteilt
• [x] Sie haben ein Schlüsselpaar zur Verwendung mit SSH erstellt

Erstellen einer TF-Datei

Ich werde über die tf-Datei erklären.

Wechseln Sie zuerst in ein beliebiges Arbeitsverzeichnis. In diesem Artikel lautet die Verzeichnisstruktur wie folgt, und das aktuelle Verzeichnis ist das allgemeine Verzeichnis. Bei anderen Verzeichnissen gibt es kein Problem hinsichtlich des Speicherorts des SSH-Verzeichnisses.

--Verzeichnisaufbau

.
|-- common
|   |--  userdata
|        |-- cloud-init.tpl
|   |-- ec2.tf
|   |-- env-vars
|   |-- network.tf
|   |-- provider.tf
|   |-- rds.tf
`-- ssh
    |-- id_rsa
    |-- id_rsa.pub

• Verschiedene Dateierklärungen

• env-vars

### Authentication
export TF_VAR_aws_access_key="＜access_Fügen Sie den Inhalt des Schlüssels ＞ ein"
export TF_VAR_aws_secret_key="＜secret_Fügen Sie den Inhalt des Schlüssels ＞ ein"

(*) Fügen Sie den Inhalt von access_key und secret_key in die Anführungszeichen ein.

• provider.tf

# Variable
variable "aws_access_key" {}
variable "aws_secret_key" {}
variable "region" {
    default = "ap-northeast-1"
}

# Provider
provider "aws" {
    access_key = var.aws_access_key
    secret_key = var.aws_secret_key
    region = "ap-northeast-1"
}

• network.tf

# vpc
resource "aws_vpc" "dev-env" {
    cidr_block = "10.0.0.0/16"
    instance_tenancy = "default"
    enable_dns_support = "true"
    enable_dns_hostnames = "false"
    tags = {
      Name = "dev-env"
    }
}

# subnet
## public
resource "aws_subnet" "public-web" {
    vpc_id = "${aws_vpc.dev-env.id}"
    cidr_block = "10.0.1.0/24"
    availability_zone = "ap-northeast-1a"
    tags = {
      Name = "public-web"
    }
}

## praivate
resource "aws_subnet" "private-db1" {
    vpc_id = "${aws_vpc.dev-env.id}"
    cidr_block = "10.0.2.0/24"
    availability_zone = "ap-northeast-1a"
    tags = {
      Name = "private-db1"
    }
}

resource "aws_subnet" "private-db2" {
    vpc_id = "${aws_vpc.dev-env.id}"
    cidr_block = "10.0.3.0/24"
    availability_zone = "ap-northeast-1c"
    tags = {
      Name = "private-db2"
    }
}

# route table
resource "aws_route_table" "public-route" {
    vpc_id = "${aws_vpc.dev-env.id}"
    route {
        cidr_block = "0.0.0.0/0"
        gateway_id = "${aws_internet_gateway.dev-env-gw.id}"
    }
    tags = {
      Name = "public-route"
    }
}

resource "aws_route_table_association" "public-a" {
    subnet_id = "${aws_subnet.public-web.id}"
    route_table_id = "${aws_route_table.public-route.id}"
}

# internet gateway
resource "aws_internet_gateway" "dev-env-gw" {
    vpc_id = "${aws_vpc.dev-env.id}"
    depends_on = [aws_vpc.dev-env]
    tags = {
      Name = "dev-env-gw"
    }
}

• ec2.tf

# Security Group
resource "aws_security_group" "public-web-sg" {
    name = "public-web-sg"
    vpc_id = "${aws_vpc.dev-env.id}"
    ingress {
        from_port = 22
        to_port = 22
        protocol = "tcp"
        cidr_blocks = ["0.0.0.0/0"]
    }

    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 = "public-web-sg"
    }
}

resource "aws_security_group" "praivate-db-sg" {
    name = "praivate-db-sg"
    vpc_id = "${aws_vpc.dev-env.id}"
    ingress {
        from_port = 5432
        to_port = 5432
        protocol = "tcp"
        cidr_blocks = ["10.0.1.0/24"]
    }

    egress {
        from_port = 0
        to_port = 0
        protocol = "-1"
        cidr_blocks = ["0.0.0.0/0"]
    }
    tags = {
      Name = "public-db-sg"
    }
}

# EC2 Key Pairs
resource "aws_key_pair" "common-ssh" {
  key_name   = "common-ssh"
  public_key = "<Fügen Sie den Inhalt des öffentlichen Schlüssels ein>"
}

# EC2
resource "aws_instance" "webserver" {
    ami = "ami-011facbea5ec0363b"
    instance_type = "t2.micro"
    key_name   = "common-ssh"
    vpc_security_group_ids = [
      "${aws_security_group.public-web-sg.id}"
    ]
    subnet_id = "${aws_subnet.public-web.id}"
    associate_public_ip_address = "true"
    ebs_block_device {
      device_name    = "/dev/xvda"
      volume_type = "gp2"
      volume_size = 30
      }
    user_data          = "${file("./userdata/cloud-init.tpl")}"
    tags  = {
        Name = "webserver"
    }
}

# Output
output "public_ip_of_webserver" {
  value = "${aws_instance.webserver.public_ip}"
}

(*) Cidr_blocks, beschrieben in Sicherheitsgruppe, ist ein Beispiel. Achten Sie bei der tatsächlichen Verwendung besonders auf die Sicherheit. Insbesondere SSH sollte die Quelle einschränken.

• rds.tf

# RDS
resource "aws_db_subnet_group" "praivate-db" {
    name        = "praivate-db"
    subnet_ids  = ["${aws_subnet.private-db1.id}", "${aws_subnet.private-db2.id}"]
    tags = {
        Name = "praivate-db"
    }
}

resource "aws_db_instance" "test-db" {
  identifier           = "test-db"
  allocated_storage    = 20
  storage_type         = "gp2"
  engine               = "postgres"
  engine_version       = "11.5"
  instance_class       = "db.t3.micro"
  name                 = "testdb"
  username             = "test"
  password             = "test"
  vpc_security_group_ids  = ["${aws_security_group.praivate-db-sg.id}"]
  db_subnet_group_name = "${aws_db_subnet_group.praivate-db.name}"
  skip_final_snapshot = true
}

(*) Der Passwortwert wird als Beispiel angezeigt. Nicht alle Zeichenfolgen können verwendet werden.

• cloud-init.tpl

#cloud-config

runcmd:
#Ändern Sie den Hostnamen
  - hostnamectl set-hostname webserver

#Paketinstallation
##Es werden nur sicherheitsrelevante Updates installiert
  - yum update --security -y

## PostgreSQL client programs
  - yum install -y postgresql.x86_64

#Zeitzonenänderung
##Sicherung der Konfigurationsdatei
  - cp  -p /etc/localtime /etc/localtime.org

##Erstellen Sie einen symbolischen Link
  - ln -sf  /usr/share/zoneinfo/Asia/Tokyo /etc/localtime

Terraform-Konstruktion

Führen Sie zunächst die folgenden Vorbereitungsarbeiten durch.

• Umgebungsvariablen aktivieren $ source env-vars
• Bestätigung von Umgebungsvariablen $ env

Nach Abschluss der Vorbereitungsarbeiten ist es endlich Zeit, Terraform zu bauen. Terraform Bauarbeiten sind die nächsten 3 Schritte!

1. Initialisieren Sie mit "Terraform darin"
2. Bestätigen Sie mit "Terraform Plan"
3. Mit "Terraform Apply" auftragen

Die Erläuterung des Befehls "terraform" entfällt.

Nach dem Ausführen von terraform apply wird jede Ressource erstellt, wenn die Meldung ** Apply complete! ** ausgegeben wird. 　 Sie können eine Verbindung zu RDS herstellen, indem Sie psql von einer EC2-Instanz oder von einem SQL-Client wie DBeaver über SSH ausführen.

terraform apply

plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # aws_db_instance.test-db will be created
  + resource "aws_db_instance" "test-db" {
      + address                               = (known after apply)
      + allocated_storage                     = 20
      + apply_immediately                     = (known after apply)
      + arn                                   = (known after apply)
      + auto_minor_version_upgrade            = true
      + availability_zone                     = (known after apply)
      + backup_retention_period               = (known after apply)
      + backup_window                         = (known after apply)
      + ca_cert_identifier                    = (known after apply)
      + character_set_name                    = (known after apply)
      + copy_tags_to_snapshot                 = false
      + db_subnet_group_name                  = "praivate-db"
      + endpoint                              = (known after apply)
      + engine                                = "postgres"
      + engine_version                        = "11.5"
      + hosted_zone_id                        = (known after apply)
      + id                                    = (known after apply)
      + identifier                            = "test-db"
      + identifier_prefix                     = (known after apply)
      + instance_class                        = "db.t3.micro"
      + kms_key_id                            = (known after apply)
      + license_model                         = (known after apply)
      + maintenance_window                    = (known after apply)
      + monitoring_interval                   = 0
      + monitoring_role_arn                   = (known after apply)
      + multi_az                              = (known after apply)
      + name                                  = "testdb"
      + option_group_name                     = (known after apply)
      + parameter_group_name                  = (known after apply)
      + password                              = (sensitive value)
      + performance_insights_enabled          = false
      + performance_insights_kms_key_id       = (known after apply)
      + performance_insights_retention_period = (known after apply)
      + port                                  = (known after apply)
      + publicly_accessible                   = false
      + replicas                              = (known after apply)
      + resource_id                           = (known after apply)
      + skip_final_snapshot                   = true
      + status                                = (known after apply)
      + storage_type                          = "gp2"
      + timezone                              = (known after apply)
      + username                              = "test"
      + vpc_security_group_ids                = (known after apply)
    }

/*Unterlassung*/

aws_db_instance.test-db: Still creating... [3m0s elapsed]
aws_db_instance.test-db: Creation complete after 3m5s [id=test-db]

Apply complete! Resources: 13 added, 0 changed, 0 destroyed.

Outputs:

public_ip_of_webserver =<IP-Adresse (*)>

(*) Die öffentliche EC2-IP wird ausgegeben.

Wissen

Die Punkte, die beim Erstellen von Ressourcen in der AWS-Umgebung zu beachten sind, werden nachfolgend beschrieben.

• Verfügbarkeitszone Für die Erstellung eines RDS müssen mehrere Verfügbarkeitszonen angegeben werden. Es kann nicht selbst erstellt werden. Zum Zeitpunkt des Schreibens dieses Artikels müssen im Fall von Japan Relusion die folgenden zwei Verfügbarkeitszonen angegeben werden.

zones: ap-northeast-1c, ap-northeast-1a, ap-northeast-1d.

• Wenn Sie RDS löschen möchten, wenn Sie "Terraform Destroy" ausführen Für RDS muss beim Löschen einer Ressource standardmäßig ein Snapshot erstellt werden. Daher muss die Option "skip_final_snapshot" in der tf-Datei auf "true" gesetzt sein, um eine "Terraform-Zerstörung" durchzuführen. Der Standardwert ist false. Seien Sie vorsichtig, wenn Sie dies in einer Produktionsumgebung tun.

--RDS PostgreSQL-Spezifikationen Der Standardwert für PostgreSQL-Kollatierung und Ctype in RDS ist ** en_US.UTF-8 **. Wenn Sie die Leistung in Betracht ziehen, ist es besser, eine Verbindung mit psql herzustellen, sie zu löschen und neu zu erstellen.

--Wenn Sie mit Openssh ein SSH-Schlüsselpaar erstellen Wenn Sie in Openssh ein SSH-Schlüsselpaar erstellen und mit einem SQL-Client wie DBeaver eine Verbindung über SSH herstellen, müssen Sie das Schlüsselformat ändern.

abschließend

Das war's für Terraform 3 Minuten Kochen: Kochen :.