[LINUX] Construisez AWS EC2 et RDS avec Terraform Terraform 3 minutes de cuisson

introduction

Cet article décrit comment créer AWS EC2 et RDS avec Terraform.

L'exécution avec terraform apply prend environ 3 minutes. Il peut être construit avec le temps d'attente des ramen en tasse.

L'environnement suivant (*) sera déployé. En outre, EC2 effectue également la configuration minimale du système d'exploitation.

Si vous souhaitez partir des bases de Terraform, veuillez vous reporter à la version précédente La vraie valeur de l'automatisation Terraform à partir d'Oracle Cloud.

(*) Le fichier tf décrit dans cet article est disponible sur GitHub.

Construction Terraform

Pour créer avec Terraform dans l'environnement AWS, créez un utilisateur avec IAM et préparez les informations d'identification nécessaires. Après cela, installez Terraform et préparez le fichier tf nécessaire à l'exécution de Terraform.

Les prérequis pour l'environnement AWS sont répertoriés ci-dessous.

• [x] Créer un utilisateur avec IAM
• [x] Vous avez accordé les autorisations requises
• [x] Vous avez créé une paire de clés à utiliser avec SSH

Créer un fichier tf

Je vais vous expliquer le fichier tf.

Déplacez-vous d'abord vers n'importe quel répertoire de travail. Dans cet article, la structure des répertoires est la suivante et le répertoire actuel est le répertoire commun. Il n'y a aucun problème avec les autres répertoires concernant l'emplacement du répertoire ssh.

• Structure du répertoire

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

--Diverses explications sur les fichiers

• env-vars

### Authentication
export TF_VAR_aws_access_key="＜access_Collez le contenu de la clé ＞"
export TF_VAR_aws_secret_key="＜secret_Collez le contenu de la clé ＞"

(*) Collez le contenu de access_key et secret_key dans les guillemets, respectivement.

• 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 = "<Coller le contenu de la clé publique>"
}

# 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 décrit dans Security Group est un exemple. Lorsque vous l'utilisez réellement, portez une attention particulière à la sécurité, et en particulier SSH doit limiter la source.

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

(*) La valeur du mot de passe est indiquée à titre d'exemple. Toutes les chaînes ne peuvent pas être utilisées.

• cloud-init.tpl

#cloud-config

runcmd:
#Changer le nom d'hôte
  - hostnamectl set-hostname webserver

#Installation du package
##Seules les mises à jour liées à la sécurité installées
  - yum update --security -y

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

#Changement de fuseau horaire
##Sauvegarde du fichier de configuration
  - cp  -p /etc/localtime /etc/localtime.org

##Créer un lien symbolique
  - ln -sf  /usr/share/zoneinfo/Asia/Tokyo /etc/localtime

Construction Terraform

Tout d'abord, effectuez les travaux préparatoires suivants.

• Activer les variables d'environnement $ source env-vars --Confirmation des variables d'environnement $ env

Après avoir terminé les travaux préparatoires, il est enfin temps de construire Terraform. Les travaux de construction de Terraform sont les 3 prochaines étapes!

1. Initialisez avec terraform dedans
2. Confirmer avec le plan terraform
3. Appliquer avec terraform apply

L'explication de la commande «terraform» est omise.

Après avoir exécuté terraform apply, chaque ressource sera créée lorsque le message ** Apply complete! ** est sorti. 　 Vous pouvez vous connecter à RDS en exécutant psql à partir d'une instance EC2 ou à partir d'un client SQL tel que DBeaver via SSH.

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

/*Omission*/

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 =<Adresse IP (*)>

(*) IP publique EC2 est sortie.

connaissance

Les points à garder à l'esprit lors de la création de ressources dans l'environnement AWS sont décrits ci-dessous.

--Zone de disponibilité La création d'un RDS nécessite la spécification de plusieurs zones de disponibilité. Il ne peut pas être créé par lui-même. Au moment de la rédaction de cet article, dans le cas de Japan Relusion, il est nécessaire de spécifier les deux zones de disponibilité suivantes.

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

--Si vous souhaitez supprimer RDS lors de l'exécution de terraform destroy RDS exige qu'un instantané soit créé par défaut lors de la suppression d'une ressource, donc l'option skip_final_snapshot doit être définie sur true dans le fichier tf afin de faire une destruction de la terraforme. Le défaut est faux. Soyez prudent lorsque vous le faites dans un environnement de production.

• Spécifications RDS PostgreSQL La valeur par défaut pour le classement PostgreSQL et Ctype dans RDS est ** en_US.UTF-8 **. En ce qui concerne les performances, il semble préférable de se connecter à psql, de le supprimer et de le recréer.

--Lorsque vous créez une paire de clés SSH avec Openssh Si vous créez une paire de clés SSH dans Openssh et que vous vous connectez via SSH à l'aide d'un client SQL tel que DBeaver, vous devrez modifier le format de clé.

en conclusion

Voilà pour Terraform 3 minutes de cuisson: cuisson:.