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.

terraform.png

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.

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.

.
|-- 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

nom de fichier rôle
cloud-init.tpl Script de construction initiale pour EC2
ec2.tf Fichier tf EC2
env-vars Fichier tf des variables utilisées par le fournisseur
network.tf Fichier tf réseau
provider.tf Fichier tf du fournisseur
rds.tf Fichier tf RDS
id_rsa Clé privée SSH
id_rsa.pub Clé publique SSH
### 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.

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

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.

--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:.

Recommended Posts

Construisez AWS EC2 et RDS avec Terraform Terraform 3 minutes de cuisson
Créez facilement une infrastructure réseau et EC2 avec AWS CDK Python
Créez Amazon Linux avec AWS EC2 et connectez-vous
Construction de l'environnement Ruby avec AWS EC2
[AWS] Construire ECR avec AWS CDK
Gérez vos données avec AWS RDS
Authentification sans mot de passe avec RDS et IAM (Python)
Utiliser Jupyter Lab et Jupyter Notebook avec EC2
Lancement de l'instance AWS EC2 et connexion SSH
[AWS] Associez Lambda et S3 à boto3
Écraser les données dans RDS avec AWS Glue
Touchez AWS avec Serverless Framework et Python
Créer un environnement de développement TensorFlow sur Amazon EC2 avec une copie de commande
Créez un environnement WardPress sur AWS avec Pulumi
Créer un environnement python avec pyenv sur EC2 (ubuntu)
Créez une reconnaissance faciale sans serveur avec Terraform (Amazon Rekognition)
Créez un système de synthèse bon marché avec des composants AWS
Créez un environnement Django avec Vagrant en 5 minutes
[AWS] Construisons un cluster ECS avec CDK
Créez un environnement virtuel avec pyenv et venv
Décrivez ec2 avec boto3 et récupérez la valeur
[AWS EC2] Comment installer uniquement le client MySQL sur Amazon Linux 2 et se connecter à RDS