TF rename variables

Author: DmitryFomin1

README.md

@@ -14,7 +14,7 @@ Your source PostgreSQL database can be located anywhere, but DLE with other comp
 - [Terraform Installed](https://learn.hashicorp.com/tutorials/terraform/install-cli) (minimal version: 1.0.0)
 - AWS [Route 53](https://aws.amazon.com/route53/) Hosted Zone (For setting up TLS) for a domain or sub-domain you control
 - You must have AWS Access Keys and a default region in your Terraform environment (See section on required IAM Permissions)
-- The DLE runs on an EC2 instance which can be accessed using a selected set of SSH keys uploaded to EC2. Use the Terraform parameter `keypair` to specify which EC2 Keypair to use
+- The DLE runs on an EC2 instance which can be accessed using a selected set of SSH keys uploaded to EC2. Use the Terraform parameter `aws_keypair` to specify which EC2 Keypair to use
 - Required IAM Permissions: to successfully run this Terraform module, the IAM User/Role must have the following permissions:
     * Read/Write permissions on EC2
     * Read/Write permissions on Route53
@@ -33,8 +33,8 @@ Your source PostgreSQL database can be located anywhere, but DLE with other comp
 ## Quick start
 The following steps were tested on Ubuntu 20.04 but supposed to be valid for other Linux distributions without significant modification.
 
- 1. SSH to any machine with internet access, it will be used as deployment machine
- 1. Install Terraform  https://learn.hashicorp.com/tutorials/terraform/install-cli. Example for Ubuntu:
+1. SSH to any machine with internet access, it will be used as deployment machine
+1. Install Terraform  https://learn.hashicorp.com/tutorials/terraform/install-cli. Example for Ubuntu:
     ```shell
     sudo apt-get update && sudo apt-get install -y gnupg software-properties-common curl 
     curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
@@ -43,39 +43,45 @@ The following steps were tested on Ubuntu 20.04 but supposed to be valid for oth
     # Verify installation.
     terraform -help
     ```
- 1. Get TF code for Database Lab:
+1. Get TF code for Database Lab:
     ```shell
     git clone https://gitlab.com/postgres-ai/database-lab-infrastructure.git
     cd database-lab-infrastructure/
     ```
- 1. Edit `terraform.tfvars` file. In our example, we will use Heroku demo database as a source:
-    ```shell
-    dle_ami_name = "DBLABserver*"
-    dle_version_full = "2.3.3"
-    aws_region = "us-east-2"
-    instance_type = "t2.large"
-    keypair = "postgres_ext_test"
-    allow_ssh_from_cidrs = ["0.0.0.0/0"]
-    tag_name = "DBLABserver-ec2instance"
-    availability_zone="us-east-2a"
-    ebs_size="40"
-    ebs_type="gp2"
-    postgres_source_dbname="d3dljqkrnopdvg"
-    postgres_source_host="ec2-3-215-57-87.compute-1.amazonaws.com"
-    postgres_source_port="5432"
-    postgres_source_version="13"
-    postgres_config_shared_preload_libraries="pg_stat_statements"
-    dle_debug="true"
+1. Edit `terraform.tfvars` file. In our example, we will use Heroku demo database as a source:
+    ```config
+    dle_version_full = "2.4.0"
+
+    aws_ami_name = "DBLABserver*"
+    aws_keypair = "YOUR_AWS_KEYPAIR"
+
+    aws_deploy_region = "us-east-1"
+    aws_deploy_ebs_availability_zone="us-east-1a"
+    aws_deploy_ec2_instance_type = "t2.large"
+    aws_deploy_ec2_instance_tag_name = "DBLABserver-ec2instance"
+    aws_deploy_ebs_size="40"
+    aws_deploy_ebs_type="gp2"
+    aws_deploy_allow_ssh_from_cidrs = ["0.0.0.0/0"]
+    aws_deploy_dns_api_subdomain="tf-test" # subdomain in aws.postgres.ai, fqdn will be ${dns_api_subdomain}-engine.aws.postgres
+
+    source_postgres_version="13"
+    source_postgres_host="ec2-3-215-57-87.compute-1.amazonaws.com"
+    source_postgres_port="5432"
+    source_postgres_dbname="d3dljqkrnopdvg"
+    source_postgres_username="postgres"
+
+    dle_debug_mode="true"
     dle_retrieval_refresh_timetable="0 0 * * 0"
+    postgres_config_shared_preload_libraries="pg_stat_statements"
+
     platform_project_name="aws_test_tf"
-    dns_api_subdomain="tf-test" #subdomain in aws.postgres.ai, fqdn will be ${dns_api_subdomain}-engine.aws.postgres.ai
     ```
-1. Create `secret.tfvars` containing `postgres_source_password`, `platform_token`, and `github_vcs_secret_token`. An example:
-    ```shell
-    postgres_source_username="postgres"    # todo: move to regular tfvars
-    postgres_source_password="password"
-    platform_token="platform_token" # from https://console.postgres.ai/postgres-ai-team/tokens  # todo your org
-    github_vcs_secret_token="vcs_secret_token"  # todo: how to get it?
+1. Create `secret.tfvars` containing `source_postgres_password`, `platform_access_token`, and `vcs_github_secret_token`. An example:
+    ```config
+    source_postgres_password="YOUR_DB_PASSWORD" # todo: put pwd for heroku example DB here
+    platform_access_token="YOUR_ACCESS_TOKEN"   # to generate, open https://console.postgres.ai/, choose your organization,
+                                                # then "Access tokens" in the left menu
+    vcs_github_secret_token="vcs_secret_token"  # to generate, open https://github.com/settings/tokens/new
     ```
 1. Initialize
     ```shell
@@ -91,13 +97,13 @@ The following steps were tested on Ubuntu 20.04 but supposed to be valid for oth
     terraform  apply -var-file="secret.tfvars" -auto-approve
     ```
 1. If everything goes well, you should get an output like this:
-    ```
-    ci_observer_token = "gsio7KmgaxECfJ80kUx2tUeIf4kEXZex"
+    ```config
+    vcs_db_migration_checker_verification_token = "gsio7KmgaxECfJ80kUx2tUeIf4kEXZex"
     dle_verification_token = "zXPodd13LyQaKgVXGmSCeB8TUtnGNnIa"
     ec2_public_dns = "ec2-18-118-126-25.us-east-2.compute.amazonaws.com"
     ec2instance = "i-0b07738148950af25"
     ip = "18.118.126.25"
-    joe_signing_secret = "lG23qZbUh2kq0ULIBfW6TRwKzqGZu1aP"
+    platform_joe_signing_secret = "lG23qZbUh2kq0ULIBfW6TRwKzqGZu1aP"
     public_dns_name = "demo-api-engine.aws.postgres.ai"  # todo: this should be URL, not hostname – further we'll need URL, with protocol – `https://`
     ```
 
@@ -122,7 +128,7 @@ The following steps were tested on Ubuntu 20.04 but supposed to be valid for oth
     <img src="/uploads/8371e7f79de199aa017ff2df82b8f704/image.png" width="400" />
  1. Add Joe chatbot for efficient SQL optimization workflow:
     1. Go to the "SQL Optimization > Ask Joe" page using the left menu, click the "Add instance" button, specify the same project as you defined in the previous step
-    1. `Signing secret` – use `joe_signing_secret` from the Terraform output
+    1. `Signing secret` – use `platform_joe_signing_secret` from the Terraform output
     1. `URL` – use `public_dns_name` values from the Terraform output with port `444`; in our example, it's `https://demo-api-engine.aws.postgres.ai:444`
     1. Press "Verify URL" to check connectivity and then press "Add". You should see:
     <img src="/uploads/252e5f74cd324fc4df301bbf7c2bdd25/image.png" width="400" />

ami.tf

@@ -1,10 +1,10 @@
 data "aws_ami" "ami" {
   most_recent      = true
-  owners           = ["${var.ami_owner}"]
+  owners           = ["${var.aws_ami_owner}"]
 
   filter {
     name   = "name"
-    values = ["${var.dle_ami_name}"]
+    values = ["${var.aws_ami_name}"]
   }
   filter {
     name   = "root-device-type"

api_dns.tf

@@ -9,7 +9,7 @@
 
 
 data "aws_route53_zone" "dblab_zone" {
-  name = var.dns_zone_name
+  name = var.aws_deploy_dns_zone_name
 }
 
 ###
@@ -20,7 +20,7 @@ data "aws_route53_zone" "dblab_zone" {
 # resource should be close to correct.
 #
 #resource "aws_route53_record" "dblab_api_subdomain_caa" {
-#  name = var.dns_zone_name
+#  name = var.aws_deploy_dns_zone_name
 #  type = "CAA"
 #
 #  records = [
@@ -35,7 +35,7 @@ data "aws_route53_zone" "dblab_zone" {
 #}
 
 resource "aws_route53_record" "dblab_api_subdomain" {
-  name = var.dns_api_subdomain
+  name = var.aws_deploy_dns_api_subdomain
   type = "CNAME"
 
   records = [
@@ -47,7 +47,7 @@ resource "aws_route53_record" "dblab_api_subdomain" {
 }
 
 resource "aws_acm_certificate" "dblab_api_subdomain_cert" {
-  domain_name       = "${var.dns_api_subdomain}.${var.dns_zone_name}"
+  domain_name       = "${var.aws_deploy_dns_api_subdomain}.${var.aws_deploy_dns_zone_name}"
   validation_method = "DNS"
 
   lifecycle {

clones_dns.tf

@@ -1,5 +1,5 @@
 resource "aws_route53_record" "dblab_clones_subdomain" {
-  name = "${var.dns_api_subdomain}-engine"
+  name = "${var.aws_deploy_dns_api_subdomain}-engine"
   type = "CNAME"
 
   # TODO -- Allocate an Elastic IP address for the instance rather than using the

dle-logical-init.sh.tpl

@@ -78,16 +78,16 @@ done
 mkdir ~/.dblab 
 #cp /home/ubuntu/.dblab/config.example.logical_generic.yml ~/.dblab/server.yml
 curl https://gitlab.com/postgres-ai/database-lab/-/raw/${dle_version_full}/configs/config.example.logical_generic.yml --output ~/.dblab/server.yml
-sed -ri "s/^(\s*)(debug:.*$)/\1debug: ${dle_debug}/" ~/.dblab/server.yml
+sed -ri "s/^(\s*)(debug:.*$)/\1debug: ${dle_debug_mode}/" ~/.dblab/server.yml
 sed -ri "s/^(\s*)(timetable:.*$)/\1timetable: \"${dle_retrieval_refresh_timetable}\"/" ~/.dblab/server.yml
 sed -ri "s/^(\s*)(forceInit:.*$)/\1forceInit: true/" ~/.dblab/server.yml
-sed -ri "s/^(\s*)(verificationToken:.*$)/\1verificationToken: ${dle_token}/" ~/.dblab/server.yml
-sed -ri "s/^(\s*)(dbname:.*$)/\1dbname: ${postgres_source_dbname}/" ~/.dblab/server.yml
-sed -ri "s/^(\s*)(host: 34.56.78.90$)/\1host: ${postgres_source_host}/" ~/.dblab/server.yml
-sed -ri "s/^(\s*)(port: 5432$)/\1port: ${postgres_source_port}/" ~/.dblab/server.yml
-sed -ri "s/^(\s*)(            username: postgres$)/\1            username: ${postgres_source_username}/" ~/.dblab/server.yml
-sed -ri "s/^(\s*)(password:.*$)/\1password: ${postgres_source_password}/" ~/.dblab/server.yml
-sed -ri "s/:13/:${postgres_source_version}/g"  ~/.dblab/server.yml
+sed -ri "s/^(\s*)(verificationToken:.*$)/\1verificationToken: ${dle_verification_token}/" ~/.dblab/server.yml
+sed -ri "s/^(\s*)(dbname:.*$)/\1dbname: ${source_postgres_dbname}/" ~/.dblab/server.yml
+sed -ri "s/^(\s*)(host: 34.56.78.90$)/\1host: ${source_postgres_host}/" ~/.dblab/server.yml
+sed -ri "s/^(\s*)(port: 5432$)/\1port: ${source_postgres_port}/" ~/.dblab/server.yml
+sed -ri "s/^(\s*)(            username: postgres$)/\1            username: ${source_postgres_username}/" ~/.dblab/server.yml
+sed -ri "s/^(\s*)(password:.*$)/\1password: ${source_postgres_password}/" ~/.dblab/server.yml
+sed -ri "s/:13/:${source_postgres_version}/g"  ~/.dblab/server.yml
 #restore pg_dump via pipe -  without saving it on the disk
 sed -ri "s/^(\s*)(parallelJobs:.*$)/\1parallelJobs: 1/" ~/.dblab/server.yml
 sed -ri "s/^(\s*)(# immediateRestore:.*$)/\1immediateRestore: /" ~/.dblab/server.yml
@@ -99,7 +99,7 @@ sed -ri "s/^(\s*)(- logicalRestore.*$)/\1#- logicalRestore /" ~/.dblab/server.ym
 # Enable Platform
 sed -ri "s/^(\s*)(#platform:$)/\1platform: /" ~/.dblab/server.yml
 sed -ri "s/^(\s*)(#  url: \"https\\:\\/\\/postgres.ai\\/api\\/general\"$)/\1  url: \"https\\:\\/\\/postgres.ai\\/api\\/general\" /" ~/.dblab/server.yml
-sed -ri "s/^(\s*)(#  accessToken: \"platform_access_token\"$)/\1  accessToken: \"${platform_token}\"/" ~/.dblab/server.yml
+sed -ri "s/^(\s*)(#  accessToken: \"platform_access_token\"$)/\1  accessToken: \"${platform_access_token}\"/" ~/.dblab/server.yml
 sed -ri "s/^(\s*)(#  enablePersonalTokens: true$)/\1  enablePersonalTokens: true/" ~/.dblab/server.yml
 
 
@@ -126,17 +126,17 @@ done
 dblab init \
  --environment-id=tutorial \
  --url=http://localhost:2345 \
- --token=${dle_token} \
+ --token=${dle_verification_token} \
  --insecure
 
 #configure and run Joe Bot container
 cp /home/ubuntu/joe.yml ~/.dblab/joe.yml
-sed -ri "s/^(\s*)(debug:.*$)/\1debug: ${dle_debug}/" ~/.dblab/joe.yml
-sed -ri "s/^(\s*)(  token:.*$)/\1  token: ${platform_token}/" ~/.dblab/joe.yml
-sed -ri "s/^(\s*)(     token:.*$)/\1     token: ${dle_token}/" ~/.dblab/joe.yml
-sed -ri "s/^(\s*)(    url:.*$)/\1    url: \"http\\:\\/\\/${dns_api_subdomain}-engine.aws.postgres.ai\\:2345\"/" ~/.dblab/joe.yml
-sed -ri "s/^(\s*)(dbname:.*$)/\1dbname: ${postgres_source_dbname}/" ~/.dblab/joe.yml
-sed -ri "s/^(\s*)(signingSecret:.*$)/\1signingSecret: ${joe_signing_secret}/" ~/.dblab/joe.yml
+sed -ri "s/^(\s*)(debug:.*$)/\1debug: ${dle_debug_mode}/" ~/.dblab/joe.yml
+sed -ri "s/^(\s*)(  token:.*$)/\1  token: ${platform_access_token}/" ~/.dblab/joe.yml
+sed -ri "s/^(\s*)(     token:.*$)/\1     token: ${dle_verification_token}/" ~/.dblab/joe.yml
+sed -ri "s/^(\s*)(    url:.*$)/\1    url: \"http\\:\\/\\/${aws_deploy_dns_api_subdomain}-engine.aws.postgres.ai\\:2345\"/" ~/.dblab/joe.yml
+sed -ri "s/^(\s*)(dbname:.*$)/\1dbname: ${source_postgres_dbname}/" ~/.dblab/joe.yml
+sed -ri "s/^(\s*)(signingSecret:.*$)/\1signingSecret: ${platform_joe_signing_secret}/" ~/.dblab/joe.yml
 sed -ri "s/^(\s*)(project:.*$)/\1project: ${platform_project_name}/" ~/.dblab/joe.yml
 
 sudo docker run \
@@ -149,12 +149,12 @@ postgresai/joe:latest
 
 #configure and run DB Migration Checker
 curl https://gitlab.com/postgres-ai/database-lab/-/raw/master/configs/config.example.run_ci.yaml --output ~/.dblab/run_ci.yaml
-sed -ri "s/^(\s*)(debug:.*$)/\1debug: ${dle_debug}/" ~/.dblab/run_ci.yaml
-sed -ri "s/^(\s*)(  verificationToken: \"secret_token\".*$)/\1  verificationToken: ${ci_observer_token}/" ~/.dblab/run_ci.yaml
+sed -ri "s/^(\s*)(debug:.*$)/\1debug: ${dle_debug_mode}/" ~/.dblab/run_ci.yaml
+sed -ri "s/^(\s*)(  verificationToken: \"secret_token\".*$)/\1  verificationToken: ${vcs_db_migration_checker_verification_token}/" ~/.dblab/run_ci.yaml
 sed -ri "s/^(\s*)(  url: \"https\\:\\/\\/dblab.domain.com\"$)/\1  url: \"http\\:\\/\\/dblab_server\\:2345\"/" ~/.dblab/run_ci.yaml
-sed -ri "s/^(\s*)(  verificationToken: \"checker_secret_token\".*$)/\1  verificationToken: ${dle_token}/" ~/.dblab/run_ci.yaml
-sed -ri "s/^(\s*)(  accessToken:.*$)/\1  accessToken: ${platform_token}/" ~/.dblab/run_ci.yaml
-sed -ri "s/^(\s*)(  token:.*$)/\1  token: ${github_vcs_secret_token}/" ~/.dblab/run_ci.yaml
+sed -ri "s/^(\s*)(  verificationToken: \"checker_secret_token\".*$)/\1  verificationToken: ${dle_verification_token}/" ~/.dblab/run_ci.yaml
+sed -ri "s/^(\s*)(  accessToken:.*$)/\1  accessToken: ${platform_access_token}/" ~/.dblab/run_ci.yaml
+sed -ri "s/^(\s*)(  token:.*$)/\1  token: ${vcs_github_secret_token}/" ~/.dblab/run_ci.yaml
 
 sudo docker run --name dblab_ci_checker -it --detach \
 --publish 2500:2500 \

instance.tf

@@ -1,20 +1,20 @@
-resource "random_string" "dle_token" {
+resource "random_string" "dle_verification_token" {
   length  = 32
   upper   = true
   lower   = true
   number  = true
   special = false
 }
 
-resource "random_string" "joe_signing_secret" {
+resource "random_string" "platform_joe_signing_secret" {
   length  = 32
   upper   = true
   lower   = true
   number  = true
   special = false
 }
 
-resource "random_string" "ci_observer_token" {
+resource "random_string" "vcs_db_migration_checker_verification_token" {
   length  = 32
   upper   = true
   lower   = true
@@ -25,33 +25,33 @@ resource "random_string" "ci_observer_token" {
 data "template_file" "init" {
   template = "${file("dle-logical-init.sh.tpl")}"
   vars = {
-    dle_token = "${random_string.dle_token.result}"
-    dle_debug = "${var.dle_debug}"
+    dle_verification_token = "${random_string.dle_verification_token.result}"
+    dle_debug_mode = "${var.dle_debug_mode}"
     dle_retrieval_refresh_timetable = "${var.dle_retrieval_refresh_timetable}"
-    dle_disks = "${join(" ",var.ec2_ebs_names)}"
+    dle_disks = "${join(" ",var.aws_deploy_ec2_volumes_names)}"
     dle_version_full = "${var.dle_version_full}"
-    dns_api_subdomain = "${var.dns_api_subdomain}"
-    postgres_source_dbname = "${var.postgres_source_dbname}"
-    postgres_source_host = "${var.postgres_source_host}"
-    postgres_source_port = "${var.postgres_source_port}"
-    postgres_source_username = "${var.postgres_source_username}"
-    postgres_source_password = "${var.postgres_source_password}"
-    postgres_source_version = "${var.postgres_source_version}"
+    aws_deploy_dns_api_subdomain = "${var.aws_deploy_dns_api_subdomain}"
+    source_postgres_dbname = "${var.source_postgres_dbname}"
+    source_postgres_host = "${var.source_postgres_host}"
+    source_postgres_port = "${var.source_postgres_port}"
+    source_postgres_username = "${var.source_postgres_username}"
+    source_postgres_password = "${var.source_postgres_password}"
+    source_postgres_version = "${var.source_postgres_version}"
     postgres_config_shared_preload_libraries = "${var.postgres_config_shared_preload_libraries}"
-    platform_token = "${var.platform_token}"
+    platform_access_token = "${var.platform_access_token}"
     platform_project_name = "${var.platform_project_name}"
-    joe_signing_secret = "${random_string.joe_signing_secret.result}" 
-    ci_observer_token = "${random_string.ci_observer_token.result}"
-    github_vcs_secret_token = "${var.github_vcs_secret_token}"
+    platform_joe_signing_secret = "${random_string.platform_joe_signing_secret.result}" 
+    vcs_db_migration_checker_verification_token = "${random_string.vcs_db_migration_checker_verification_token.result}"
+    vcs_github_secret_token = "${var.vcs_github_secret_token}"
   }
 }
 
 resource "aws_instance" "aws_ec2" {
   ami               = "${data.aws_ami.ami.id}"
-  availability_zone = "${var.availability_zone}"
-  instance_type     = "${var.instance_type}"
+  availability_zone = "${var.aws_deploy_ebs_availability_zone}"
+  instance_type     = "${var.aws_deploy_ec2_instance_type}"
   security_groups   = ["${aws_security_group.dle_instance_sg.name}"]
-  key_name          = "${var.keypair}"
+  key_name          = "${var.aws_keypair}"
   tags              = "${local.common_tags}"
   user_data         = "${data.template_file.init.rendered}"
 }

main.tf

@@ -9,11 +9,11 @@ terraform {
 
 # Configure the AWS Provider
 provider "aws" {
-  region = "${var.aws_region}"
+  region = "${var.aws_deploy_region}"
 }
 
 locals {
   common_tags = {
-    Name = "${var.tag_name}"
+    Name = "${var.aws_deploy_ec2_instance_tag_name}"
   }
 }

outputs.tf

@@ -1,27 +1,27 @@
-output "ip" {
+output "aws_ec2_instance_ip" {
   value = "${aws_instance.aws_ec2.public_ip}"
 }
-output "ec2instance" {
+output "aws_ec2_instance_id" {
   value = "${aws_instance.aws_ec2.id}"
 }
-output "ec2_public_dns" {
+output "aws_ec2_instance_dns" {
   value = "${aws_instance.aws_ec2.public_dns}"
 }
-output "dle_url_for_registration" {
+output "platform_dle_registration_url" {
   value = "${format("%s://%s", "https",join("", aws_route53_record.dblab_clones_subdomain.*.fqdn))}"
 }
-output "joe_url_for_registration" {
+output "platform_joe_registration_url" {
   value = "${format("%s://%s:%s", "https",join("", aws_route53_record.dblab_clones_subdomain.*.fqdn),"444")}"
 }
 output "dle_verification_token" {
-  value = "${random_string.dle_token.result}"
+  value = "${random_string.dle_verification_token.result}"
 }
-output "joe_signing_secret" {
-  value = "${random_string.joe_signing_secret.result}"
+output "platform_joe_signing_secret" {
+  value = "${random_string.platform_joe_signing_secret.result}"
 }
-output "ci_observer_token" {
-  value = "${random_string.ci_observer_token.result}"
+output "vcs_db_migration_checker_verification_token" {
+  value = "${random_string.vcs_db_migration_checker_verification_token.result}"
 }
-output "ci_observer_url_for_registration" {
+output "vcs_db_migration_checker_registration_url" {
   value = "${format("%s://%s:%s", "https",join("", aws_route53_record.dblab_clones_subdomain.*.fqdn),"445")}"
 }