Despliegue de infraestructura cloud con Terraform

Usage: terraform [global options] <subcommand> [args]

The available commands for execution are listed below.
The primary workflow commands are given first, followed by
less common or more advanced commands.

Main commands:
  init          Prepare your working directory for other commands
  validate      Check whether the configuration is valid
  plan          Show changes required by the current configuration
  apply         Create or update infrastructure
  destroy       Destroy previously-created infrastructure

All other commands:
  console       Try Terraform expressions at an interactive command prompt
  fmt           Reformat your configuration in the standard style
  force-unlock  Release a stuck lock on the current workspace
  get           Install or upgrade remote Terraform modules
  graph         Generate a Graphviz graph of the steps in an operation
  import        Associate existing infrastructure with a Terraform resource
  login         Obtain and save credentials for a remote host
  logout        Remove locally-stored credentials for a remote host
  metadata      Metadata related commands
  output        Show output values from your root module
  providers     Show the providers required for this configuration
  refresh       Update the state to match remote systems
  show          Show the current state or a saved plan
  state         Advanced state management
  taint         Mark a resource instance as not fully functional
  test          Experimental support for module integration testing
  untaint       Remove the 'tainted' state from a resource instance
  version       Show the current Terraform version
  workspace     Workspace management

Global options (use these before the subcommand, if any):
  -chdir=DIR    Switch to a different working directory before executing the
                given subcommand.
  -help         Show this help output, or the help for a specified subcommand.
  -version      An alias for the "version" subcommand.

├── README.md
├── main.tf
├── providers.tf
├── variables.tf
├── terraform.tfvars
├── outputs.tf
├── ...
├── modules/
│   ├── moduleA/
│   │   ├── README.md
│   │   ├── main.tf
│   │   ├── providers.tf
│   │   ├── variables.tf
│   │   ├── outputs.tf
│   ├── moduleB/
│   ├── .../

terraform {
  required_version = ">= 0.14.0"
  required_providers {
    openstack = {
      source  = "terraform-provider-openstack/openstack"
      version = "~> 1.53.0"
    }
  }
}

provider "openstack" {
  user_name   = var.openstack_user_name
  tenant_name = var.openstack_tenant_name
  password    = var.PASSWORD (1)
  auth_url    = var.openstack_auth_url
}

variable "openstack_user_name" {
    description = "The username for the Tenant."
    default  = "your-openstack-user"
}

variable "PASSWORD" {
    description = "The user password."
}

variable "openstack_tenant_name" {
    description = "The name of the Tenant."
    default  = "your-openstack-project"
}

variable "openstack_auth_url" {
    description = "The endpoint url to connect to OpenStack."
    default  = "https://openstack.di.ual.es:5000/v3"
}

variable "openstack_keypair" {
    description = "The keypair to be used."
    default  = "your-openstack-keypair-name"
}

terraform init

Initializing the backend...

Initializing provider plugins...
- Reusing previous version of terraform-provider-openstack/openstack from the dependency lock file
- Using previously-installed terraform-provider-openstack/openstack v1.53.0

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.
(base) MacBook-Pro-de-Manuel:00-pruebas-carga manolo$ terraform init

Initializing the backend...

Initializing provider plugins...
- Finding terraform-provider-openstack/openstack versions matching "~> 1.53.0"...
- Installing terraform-provider-openstack/openstack v1.53.0...
- Installed terraform-provider-openstack/openstack v1.53.0 (self-signed, key ID 4F80527A391BEFD2)

Partner and community providers are signed by their developers.
If you'd like to know more about provider signing, you can read about it here:
https://www.terraform.io/docs/cli/plugins/signing.html

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

...

Terraform has been successfully initialized!

...

#Crear nodo tf_vm
resource "openstack_compute_instance_v2" "tf_vm" {(1)
  name              = "tf_vm"
  image_name        = "jammy"
  availability_zone = "nova"
  flavor_name       = "medium"
  key_pair          = var.openstack_keypair
  security_groups   = ["default"]
  network {
    name = var.openstack_network_name (2)
  }
}

resource "openstack_networking_floatingip_v2" "tf_vm_ip" { (3)
  pool = "ext-net"
}

resource "openstack_compute_floatingip_associate_v2" "tf_vm_ip" { (4)
  floating_ip = openstack_networking_floatingip_v2.tf_vm_ip.address (5)
  instance_id = openstack_compute_instance_v2.tf_vm.id (6)
}

output tf_vm_Floating_IP {
  value      = openstack_networking_floatingip_v2.tf_vm_ip.address (7)
  depends_on = [openstack_networking_floatingip_v2.tf_vm_ip] (8)
}

resource "openstack_compute_instance_v2" "tf_vm" {
  name              = "tf_vm"
  image_name        = "jammy"
  availability_zone = "nova"
  flavor_name       = "large" (1)
  key_pair          = var.openstack_keypair
  security_groups   = ["default"]
  network {
    name = var.openstack_network_name
  }
}

...

resource "openstack_blockstorage_volume_v3" "tf_vol" { (2)
  name        = "tf_vol"
  description = "first test volume"
  size        = 1 (3)
}

resource "openstack_compute_volume_attach_v2" "va_1" { (4)
  instance_id = "${openstack_compute_instance_v2.tf_vm.id}" (5)
  volume_id   = "${openstack_blockstorage_volume_v3.tf_vol.id}" (6)
}

#!/bin/bash

sudo debconf-set-selections <<< 'mysql-server mysql-server/root_password password my_password'
sudo debconf-set-selections <<< 'mysql-server mysql-server/root_password_again password my_password'
sudo apt update
sudo apt -y install mysql-server
wget https://gist.githubusercontent.com/ualmtorres/f8d0e5ea79a0e570f495087724288c6d/raw/0a894b23466bb6eea520a05559372e148e6e5803/sginit.sql -O /home/ubuntu/sginit.sql
mysql -h "localhost" -u "root" "-pmy_password" < "/home/ubuntu/sginit.sql"

sudo sed -i 's/127.0.0.1/0.0.0.0/g' /etc/mysql/mysql.conf.d/mysqld.cnf
sudo service mysql restart

#Crear nodo mysql
resource "openstack_compute_instance_v2" "mysql" {
  name              = "mysql"
  image_name        = "jammy"
  availability_zone = "nova"
  flavor_name       = "medium"
  key_pair          = var.openstack_keypair
  security_groups   = ["default"]
  network {
    name = var.openstack_network_name
  }
  user_data = file("install_mysql.sh") (1)
}

#!/bin/bash
echo "export MYSQL_SERVER=${mysql_ip}" >> /home/ubuntu/.profile (1)

sudo apt-get update
sudo apt-get install -y apache2 php php-mysql libapache2-mod-php php-mcrypt
sudo chgrp -R www-data /var/www
sudo chmod -R 775 /var/www
sudo chmod -R g+s /var/www
sudo useradd -G www-data ubuntu
sudo chown -R ubuntu /var/www/

sudo rm /var/www/html/index.html
wget https://gist.githubusercontent.com/ualmtorres/1c833f9b471fa7351e2725731596f45e/raw/a66b26d90b5f75c3a37cfe12a2370b57d2768132/sginit.php -O /var/www/html/index.php

echo "export MYSQL_SERVER=${mysql_ip}" >> /etc/apache2/envvars (2)
sudo service apache2 restart

#Crear nodo appserver
resource "openstack_compute_instance_v2" "appserver" {
  name              = "appserver"
  image_name        = "Ubuntu 16.04 LTS"
  availability_zone = "nova"
  flavor_name       = "medium"
  key_pair          = "mtorres_ual"
  security_groups   = ["default"]
  network {
    name = "desarrollo-net"
  }

    user_data = templatefile("${path.module}/install_appserver.tpl", { mysql_ip = openstack_compute_instance_v2.mysql.network.0.fixed_ip_v4 }) (1)

  depends_on = [openstack_compute_instance_v2.mysql]

}

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

Outputs:

Appserver_Floating_IP = 192.168.68.112
MySQL_Floating_IP = 192.168.68.135

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "6.5.0"
    }
  }
}

provider "google" {
  credentials = file("../gcp-identity.json") (1)

  project = var.gcp-project
  region  = "us-central1"
  zone    = "us-central1-c"
}

variable "gcp-username" {
  description = "GCP user name"
  default     = "mtorres"
}

variable "gcp-project" {
  description = "GCP project"
  default     = "cc2025-mtorres"
}

variable "gcp-network" {
  description = "GCP network"
  default     = "terraform-network"
}

Initializing the backend...

Initializing provider plugins...
- Finding hashicorp/google versions matching "6.5.0"...
- Installing hashicorp/google v6.5.0...
- Installed hashicorp/google v6.5.0 (signed by HashiCorp)

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

resource "google_compute_network" "vpc_network" {
  name = var.gcp-network
}

resource "google_compute_network" "vpc_network" {
  name = var.gcp-network
}

resource "google_compute_firewall" "firewall-icmp" {
  name    = "terraform-allow-icmp"
  network = google_compute_network.vpc_network.name

  allow {
    protocol = "icmp"
  }

  source_ranges = ["0.0.0.0/0"]
}

resource "google_compute_firewall" "firewall-ssh" {
  name    = "terraform-allow-ssh"
  network = google_compute_network.vpc_network.name

  allow {
    protocol = "tcp"
    ports    = ["22"]
  }

  source_ranges = ["0.0.0.0/0"]
}

resource "google_compute_firewall" "firewall-internal" {
  name    = "terraform-allow-internal"
  network = google_compute_network.vpc_network.name

  allow {
    protocol = "tcp"
    ports    = ["0-65535"]
  }

  allow {
    protocol = "udp"
    ports    = ["0-65535"]
  }

  allow {
    protocol = "icmp"
  }

  source_ranges = ["10.128.0.0/20"]
}

resource "google_compute_instance" "tf-vm" { (1)
  name         = "tf-vm"
  zone         = "us-central1-c"
  machine_type = "n1-standard-1"
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

  # Add SSH access to the Compute Engine instance
  metadata = {
    ssh-keys = "${var.gcp-username}:${file("~/.ssh/id_rsa.pub")}"
  }

  # Startup script
  # metadata_startup_script = "${file("update-docker.sh")}"

  network_interface { (2)
    network    = var.gcp-network
    subnetwork = var.gcp-network

    access_config {} (3)
  }
}

output "tf-vm-internal-ip" { (4)
  value      = google_compute_instance.tf-vm.network_interface.0.network_ip
  depends_on = [google_compute_instance.tf-vm]
}

output "tf-vm-ephemeral-ip" { (5)
  value      = google_compute_instance.tf-vm.network_interface.0.access_config.0.nat_ip
  depends_on = [google_compute_instance.tf-vm]
}

resource "google_compute_instance" "tf-vm" {
  name         = "tf-vm"
  zone         = "us-central1-c"
  machine_type = "n1-standard-2" (1)
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }
...
resource "google_compute_disk" "tf-disk" { (2)
  name = "tf-disk"
  type = "pd-ssd" (3)
  size = 1 (4)
}

resource "google_compute_attached_disk" "attached-tf-disk" {(5)
  disk     = google_compute_disk.tf-disk.id (6)
  instance = google_compute_instance.tf-vm.id (7)
}

$ lsblk
NAME    MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda       8:0    0   10G  0 disk (1)
├─sda1    8:1    0  9.9G  0 part /
├─sda14   8:14   0    3M  0 part
└─sda15   8:15   0  124M  0 part /boot/efi
sdb       8:16   0    1G  0 disk (2)

resource "google_compute_address" "tf-vm-ip" { (1)
  name = "ipv4-address-tf-vm"
}

resource "google_compute_instance" "tf-vm" { (2)
  name         = "tf-vm"
  machine_type = "n1-standard-1"
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-11"
    }
  }

...

  network_interface {
    network    = var.gcp-network
    subnetwork = var.gcp-network

    access_config {
      nat_ip = google_compute_address.tf-vm-ip.address (3)
    }
  }
}

output "tf-vm-ip" { (4)
  value      = google_compute_address.tf-vm-ip.address
  depends_on = [google_compute_instance.tf-vm]
}

# allow http traffic
resource "google_compute_firewall" "allow-http" {
  name    = "tf-fw-allow-http" (1)
  network = var.gcp-network (2)
  allow {
    protocol = "tcp"
    ports    = ["80"] (3)
  }
  target_tags   = ["http"] (4)
  source_ranges = ["0.0.0.0/0"] (5)
}

resource "google_compute_instance" "tf-vm" {
  name         = "tf-vm"
  zone         = "us-central1-c"
  machine_type = "n1-standard-1"
  boot_disk {
    initialize_params {
      image = "ubuntu-os-cloud/ubuntu-2204-lts" (1)
    }
  }

  # Add SSH access to the Compute Engine instance
  metadata = {
    ssh-keys = "${var.gcp-username}:${file("~/.ssh/id_rsa.pub")}"
  }

  # Add http tag to the instance to identify it in the firewall rule
  tags = ["http"] (2)

  # Startup script
  metadata_startup_script = file("setup-docker.sh") (3)

  network_interface {
    network    = var.gcp-network
    subnetwork = var.gcp-network

    access_config {}
  }
}

output "tf-vm-internal-ip" {
  value      = google_compute_instance.tf-vm.network_interface.0.network_ip
  depends_on = [google_compute_instance.tf-vm]
}

output "tf-vm-ephemeral-ip" {
  value      = google_compute_instance.tf-vm.network_interface.0.access_config.0.nat_ip
  depends_on = [google_compute_instance.tf-vm]
}

#!/bin/bash

echo "Instalando Docker"

# Add Docker's official GPG key:
apt-get update
apt-get install -y ca-certificates curl
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  tee /etc/apt/sources.list.d/docker.list > /dev/null
apt-get update

apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
systemctl enable docker

git clone https://github.com/ualmtorres/docker_customer_catalog.git (1)
cd docker_customer_catalog
docker compose up -d (2)

exit 0

# We strongly recommend using the required_providers block to set the
# Azure Provider source and version being used
terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "=4.1.0"
    }
  }
}

# Configure the Microsoft Azure Provider
provider "azurerm" {
  features {}

  subscription_id = var.azure-subscription
  tenant_id       = var.azure-tenant

}

variable "azure-subscription" {
  description = "Azure subscription id"
}

variable "azure-tenant" {
  description = "Azure tenant id"
}

variable "azure-resource-group" {
  description = "Azure resource group name"
}

variable "azure-location" {
  description = "Azure location"
}

azure-subscription = "00000000-0000-0000-0000-000000000000"
azure-tenant       = "00000000-0000-0000-0000-000000000000"
azure-resource-group = "tf-resource-group"
azure-location = "France Central"

Initializing the backend...

Initializing provider plugins...
- Finding hashicorp/azurerm versions matching "4.1.0"...
- Installing hashicorp/azurerm v4.1.0...
- Installed hashicorp/azurerm v4.1.0 (signed by HashiCorp)

Terraform has created a lock file .terraform.lock.hcl to record the provider
selections it made above. Include this file in your version control repository
so that Terraform can guarantee to make the same selections by default when
you run "terraform init" in the future.

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

resource "azurerm_resource_group" "tf-resource-group" {
  name     = var.azure-resource-group
  location = var.azure-location
}

resource "azurerm_virtual_network" "tf-net" {
  name                = var.azure-net-name
  location            = azurerm_resource_group.tf-resource-group.location
  resource_group_name = azurerm_resource_group.tf-resource-group.name
  address_space       = var.azure-address-space
  dns_servers         = var.azure-dns-servers
}

resource "azurerm_subnet" "tf-subnet" {
  name                 = var.azure-subnet-name
  resource_group_name  = azurerm_resource_group.tf-resource-group.name
  virtual_network_name = azurerm_virtual_network.tf-net.name
  address_prefixes     = var.azure-subnet-prefixes
}

...
# Nuevo contenido

variable "azure-net-name" {
  description = "Azure virtual net name"
}

variable "azure-address-space" {
  description = "Azure address space"
  type        = list(string)
}

variable "azure-dns-servers" {
  description = "Azure DNS servers"
  type        = list(string)
}

variable "azure-subnet-name" {
  description = "Azure subnet name"
}

variable "azure-subnet-prefixes" {
  description = "Azure subnet prefixes"
  type        = list(string)
}

...
# Nuevo contenido

azure-address-space        = ["10.0.0.0/24"]
azure-dns-servers          = ["8.8.8.8"]
azure-subnet-name          = "tf-subnet"
azure-subnet-prefixes      = ["10.0.0.0/24"]

resource "google_compute_instance" "instance" {
  count = length(var.instances) (1)

  name         = var.instances[count.index].name (2)
  machine_type = var.instances[count.index].flavor (3)
  boot_disk {
    initialize_params {
      image = var.instances[count.index].image (4)
    }
  }

  network_interface {
    network = google_compute_network.tf-net.self_link
  }
}

output "tf-vm-internal-ip" {
  value = [
    for vm in google_compute_instance.tf-vm : vm.network_interface.0.network_ip (1)
  ]
  depends_on = [google_compute_instance.tf-vm]
}

output "tf-vm-ephemeral-ip" {
  value = [
    for vm in google_compute_instance.tf-vm : vm.network_interface.0.access_config.0.nat_ip (2)
  ]
  depends_on = [google_compute_instance.tf-vm]
}

$ terraform apply

...

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

Outputs:

tf-vm-ephemeral-ip = [
  "34.69.211.150",
  "35.193.129.189",
]
tf-vm-internal-ip = [
  "10.128.0.11",
  "10.128.0.10",
]

...
variable "instances" {
  description = "Number of instances to create"
  type = map(object({
    name         = string,
    machine_type = string,
    image        = string
  }))
}

...
instances = {
  database = {
    name         = "database"
    machine_type = "n1-standard-1"
    image        = "debian-cloud/debian-11"
  },
  web-server = {
    name         = "web-server"
    machine_type = "n1-standard-1"
    image        = "ubuntu-os-cloud/ubuntu-2204-lts"
  }
}

resource "google_compute_instance" "instance" {
  for_each = var.instances (1)

  name         = each.value.name (2)
  zone         = var.gcp-zone
  machine_type = each.value.machine_type (3)
  boot_disk {
    initialize_params {
      image = each.value.image (4)
    }
  }

  # Startup script
  # metadata_startup_script = "${file("script.sh")}"

  network_interface {
    network    = var.gcp-network
    subnetwork = var.gcp-network

    access_config {}
  }
}

$ terraform apply

...

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

Outputs:

tf-vm-ephemeral-ip = [
  "34.132.169.85",
  "34.69.211.150",
]
tf-vm-internal-ip = [
  "10.128.0.15",
  "10.128.0.14",
]

...
module "web_server" {
  source = "./path/to/module" # Puede ser una ruta local o un repositorio remoto.
  name   = "web-server"       # Variables pasadas al módulo
  region = "us-west-1"
  ...
}
...

.
├── main.tf
├── variables.tf
├── outputs.tf
├── terraform.tfvars
├── providers.tf
└── modules
    └── instance_module
        ├── main.tf
        ├── variables.tf
        └── outputs.tf

variable "gcp-username" {
  description = "GCP user name"
}

variable "gcp-zone" {
  description = "GCP zone"
}

variable "gcp-network" {
  description = "GCP network"
}

variable "gcp-subnetwork" {
  description = "GCP subnetwork"
}

variable "instance-name" {
  description = "Name of the instance"
}

variable "machine-type" {
  description = "Machine type"
}

variable "image" {
  description = "Image"
}

resource "google_compute_instance" "tf-vm" {
  name         = var.instance-name
  zone         = var.gcp-zone
  machine_type = var.machine-type
  boot_disk {
    initialize_params {
      image = var.image
    }
  }

  # Add SSH access to the Compute Engine instance
  metadata = {
    ssh-keys = "${var.gcp-username}:${file("~/.ssh/id_rsa.pub")}"
  }

  # Startup script
  # metadata_startup_script = "${file("script.sh")}"

  network_interface {
    network    = var.gcp-network
    subnetwork = var.gcp-network

    access_config {}
  }
}

output "tf-vm-internal-ip" { (1)
  value      = google_compute_instance.tf-vm.network_interface.0.network_ip
  depends_on = [google_compute_instance.tf-vm]
}

output "tf-vm-ephemeral-ip" { (2)
  value      = google_compute_instance.tf-vm.network_interface.0.access_config.0.nat_ip
  depends_on = [google_compute_instance.tf-vm]
}

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "6.5.0"
    }
  }
}

provider "google" {
  credentials = file("./gcp-identity.json")

  project = var.gcp-project
  region  = var.gcp-region
  zone    = var.gcp-zone
}

variable "gcp-username" {
  description = "GCP user name"
}

variable "gcp-project" {
  description = "GCP project"
}

variable "gcp-region" {
  description = "GCP region"

}

variable "gcp-zone" {
  description = "GCP zone"
}

variable "gcp-network" {
  description = "GCP network"
}

variable "gcp-subnetwork" {
  description = "GCP subnetwork"
}

variable "instances" {
  description = "Number of instances to create"
  type = map(object({
    name         = string,
    machine_type = string,
    image        = string
  }))
}

gcp-username   = "your-username"
gcp-project    = "your-project"
gcp-region     = "us-central1"
gcp-zone       = "us-central1-c"
gcp-network    = "terraform-network"
gcp-subnetwork = "terraform-subnetwork"

instances = {
  database = {
    name         = "database"
    machine_type = "n1-standard-1"
    image        = "debian-cloud/debian-11"
  },
  web-server = {
    name         = "web-server"
    machine_type = "n1-standard-1"
    image        = "ubuntu-os-cloud/ubuntu-2204-lts"
  }
}

module "database" { (1)
  source         = "./instance-module" (2)
  instance-name  = var.instances.database.name (3)
  machine-type   = var.instances.database.machine_type
  image          = var.instances.database.image
  gcp-zone       = var.gcp-zone (4)
  gcp-username   = var.gcp-username
  gcp-network    = var.gcp-network
  gcp-subnetwork = var.gcp-subnetwork
}

module "web-server" {
  source         = "./instance-module"
  instance-name  = var.instances.web-server.name
  machine-type   = var.instances.web-server.machine_type
  image          = var.instances.web-server.image
  gcp-zone       = var.gcp-zone
  gcp-username   = var.gcp-username
  gcp-network    = var.gcp-network
  gcp-subnetwork = var.gcp-subnetwork
}

output "database_external_ip" {
  value = module.database.tf-vm-ephemeral-ip (1)
}

output "web-server_external_ip" {
  value = module.web-server.tf-vm-ephemeral-ip
}

output "database_internal_ip" {
  value = module.database.tf-vm-internal-ip (2)
}

output "web-server_internal_ip" {
  value = module.web-server.tf-vm-internal-ip
}