Multi-Region DC/OS on GCP using the Universal Installer

ENTERPRISE

Guide for DC/OS on GCP using the Universal Installer adding a remote region.

This guide expects that you already have a running DC/OS cluster based on Universal Installer 0.2. To learn more about running DC/OS with the Universal Installer have a look into the Guide for DC/OS on GCP using the Universal Installer.

You will learn how to place additional infrastructure into a GCP remote region. Remote regions will be connected to each other by using the peering functionality of GCP VNETs.

Prerequisites

  • A running DC/OS Enterprise cluster set up with Universal Installer 0.2 modules
  • A subnet range for your remote region

Getting started with remote region

We expect your already running DC/OS clusters main.tf will look similar to this example. To deploy a remote region we have to do some changes to your main.tf

  1. provider "google" {
  2.   version = "~> 2.0"
  3.   region  = "us-west1"
  4. }
  6. # Used to determine your public IP for forwarding rules
  7. data "http" "whatismyip" {
  8.   url = "http://whatismyip.akamai.com/"
  9. }
  11. module "dcos" {
  12.   source  = "dcos-terraform/dcos/gcp"
  13.   version = "~> 0.2.0"
  15.   providers = {
  16.     google = "google"
  17.   }
  19.   cluster_name        = "my-dcos-demo"
  20.   ssh_public_key_file = "<path-to-public-key-file>"
  21.   admin_ips           = ["${data.http.whatismyip.body}/32"]
  23.   num_masters        = 3
  24.   num_private_agents = 2
  25.   num_public_agents  = 1
  27.   dcos_version = "1.13.3"
  29.   dcos_variant              = "ee"
  30.   dcos_license_key_contents = "${file("./license.txt")}"
  32.   # Make sure to set your credentials if you do not want the default EE
  33.   # dcos_superuser_username      = "superuser-name"
  34.   # dcos_superuser_password_hash = "${file("./dcos_superuser_password_hash.sha512")}"
  36.   dcos_instance_os = "centos_7"
  37. }
  39. output "masters-ips" {
  40.   value = "${module.dcos.masters-ips}"
  41. }
  43. output "cluster-address" {
  44.   value = "${module.dcos.masters-loadbalancer}"
  45. }
  47. output "public-agents-loadbalancer" {
  48.   value = "${module.dcos.public-agents-loadbalancer}"
  49. }

Remote region provider

The first change we have to apply to your main.tf is adding a specific provider statement for the remote region. In this example we will use us-east1 with the alias us-east1 as our remote region. We also add an alias statement to the provider used deploying our region holding the master instances.

This needs to be done so our modules know which account credentials to use.

Note: Some resources have name length limitations which is the reason we shorten our region name.

  1. provider "google" {
  2.   version = "~> 2.0"
  3.   region  = "us-west1"
  4.   alias   = "master"
  5. }
  7. provider "google" {
  8.   version = "~> 2.0"
  9.   region  = "us-east1"
  10.   alias   = "us-east1"
  11. }
  13. # ...

Shared config options

To create the remote region and its infrastructure we will use the same underlying modules as in our master region. This also means there will be some information needed for both infrastructures like cluster_name, admin_ips and ssh_public_key_file. To make the operation easier you should define local variables in your main.tf that will be used in every module.

  1. #...
  3. // lets define variables which are shared between all regions
  4. locals {
  5.   ssh_public_key_file = "~/.ssh/id_rsa.pub"
  6.   cluster_name        = "my-dcos-demo"
  7.   admin_ips           = ["${data.http.whatismyip.body}/32"]
  8. }
  10. #...

Internal subnetworks

Part of the shared information is which internal subnets are used in your infrastructure. If you did not specify subnet_range, terraform uses the default which is 172.16.0.0/16. The remote region we want to specify needs its own subnet.

IMPORTANT: You should not take the next free network of 172.16/12 as 172.17.0.0/16 is dockers internal network default which will lead to problems.

To have a clear separation between our master and our remote regions we will take 10.128.0.0/16 as our remote regions subnet. Also, we will use a map variable to assign the networks to regions. This will make it easier when adding additional regions in the future.

The locals section will now look like this

  1. #...
  3. // lets define variables which are shared between all regions
  4. locals {
  5.   ssh_public_key_file = "~/.ssh/id_rsa.pub"
  6.   cluster_name        = "my-dcos-demo"
  7.   admin_ips           = ["${data.http.whatismyip.body}/32"]
  9.   region_networks = {
  10.     // dont use 172.17/26 as its used by docker.
  11.     "master"   = "172.16.0.0/16" // this is the default
  12.     "us-west1" = "10.65.0.0/16"  // default agent network, keep it for the firewall rules
  13.     "us-east1" = "10.128.0.0/16"
  14.   }
  15. }
  17. #...

The remote region

Before we start changing values within the dcos module we will append the infrastructure definition of the remote region to your main.tf. In our example case we only want to have private agents in our remote region, and both private and public agents can be put in a remote region.

IMPORTANT: Running master instances in remote regions is not supported.

To only start private agents we will set num_bootstrap = 0, num_masters = 0 and num_public_agents = 0. Due to some internal limitation we also have to tell the infrastructure module not preparing load balancers for masters and public agents with lb_disable_public_agents and lb_disable_masters

Another important topic to mention is naming. To distinguish between instances of your main and your remote region we introduced the name_prefix variable which allows you to add a prefix to the name of every resource. In this example we set the name_prefix to the short name of the remote region.

In the following example you will also find the shared config options being used in the module call referenced by e.g. local.ssh_public_key_file.

  1. #...
  3. module "dcos-use1" {
  4.   source  = "dcos-terraform/infrastructure/gcp"
  5.   version = "~> 0.2.0"
  7.   providers = {
  8.     google = "google.us-east1"
  9.   }
  11.   admin_ips   = ["${local.admin_ips}"]
  12.   name_prefix = "use1"
  14.   cluster_name               = "${local.cluster_name}"
  15.   accepted_internal_networks = "${values(local.region_networks)}"
  17.   num_bootstrap      = 0
  18.   num_masters        = 0
  19.   num_private_agents = 1
  20.   num_public_agents  = 0
  22.   lb_disable_public_agents = true
  23.   lb_disable_masters       = true
  25.   ssh_public_key_file = "${local.ssh_public_key_file}"
  26.   subnet_range        = "${local.region_networks["us-east1"]}"
  27. }

Peering to the main DC/OS region

We now need to establish a connection between the two infrastructures. The Universal Installer provides a module for this task. In this module we reference data from both infrastructures the main region holding DC/OS masters and the remote region holding your remote private agents.

The only information this module needs to receive is the output of our dcos and dcos-use1 modules. We will append this module to the end of your main.tf

Here is the example network-connection-section

  1. #...
  3. module "network-connection-master-use1" {
  4.   source  = "dcos-terraform/network-peering/gcp"
  5.   version = "~> 0.2.0"
  7.   providers = {
  8.     google.local  = "google.master"
  9.     google.remote = "google.us-east1"
  10.   }
  12.   cluster_name             = "${local.cluster_name}"
  13.   local_network_name       = "master"
  14.   local_network_self_link  = "${module.dcos.infrastructure.network_self_link}"
  15.   remote_network_name      = "use1"
  16.   remote_network_self_link = "${module.dcos-use1.network_self_link}"
  17. }

Changes to dcos module

At this point its time to do changes to your dcos module so it knows about the remote region and is able to install the remote agents.

  1. Choose a subnet range. In general this change is not needed but we wanted to make your example pretty specific.
  1. `subnet_range = "${local.region_networks["master"]}"`
  1. Add accepted internal networks. Same as in the remote region we need to specify the internal networks to allow internal traffic flow.
  1. `accepted_internal_networks = "${values(local.region_networks)}"`
  1. Change the cluster_name. As this is a shared resource we will make use of the local variable.
  1. `cluster_name = "${local.cluster_name}"`
  1. List the SSH key. This is also a shared resource and we can make use of the local variable
  1. `ssh_public_key_file = "${local.ssh_public_key_file}"`
  1. Add the admin IPs following the same pattern.
  1. `admin_ips = ["${local.admin_ips}"`]

  1. Add the private agents. This nearly the most important new variable. This tells the DC/OS installation module which other agents need to be installed.

    additional_private_agent_ips = ["${module.dcos-use1.private_agents.private_ips}"]

  2. Update the providers section. As we change to explicit alias providers we have to point our dcos module to this specific provider.

    1. providers = {
    2.   google = "google.master"
    3. }

Example dcos module

After the changes above got applied your dcos module should look like this

  1. module "dcos" {
  2.   source  = "dcos-terraform/dcos/gcp"
  3.   version = "~> 0.2.0"
  5.   providers = {
  6.     google = "google.master"
  7.   }
  9.   cluster_name        = "${local.cluster_name}"
  10.   ssh_public_key_file = "${local.ssh_public_key_file}"
  11.   admin_ips           = ["${local.admin_ips}"]
  12.   subnet_range        = "${local.region_networks["master"]}"
  14.   num_masters        = 3
  15.   num_private_agents = 2
  16.   num_public_agents  = 1
  18.   dcos_version = "1.13.3"
  20.   dcos_variant              = "ee"
  21.   dcos_license_key_contents = "${file("./license.txt")}"
  23.   # Make sure to set your credentials if you do not want the default EE
  24.   # dcos_superuser_username      = "superuser-name"
  25.   # dcos_superuser_password_hash = "${file("./dcos_superuser_password_hash.sha512")}"
  27.   dcos_instance_os = "centos_7"
  29.   accepted_internal_networks = "${values(local.region_networks)}"
  30.   additional_private_agent_ips = ["${module.dcos-use1.private_agents.private_ips}"]
  31. }

Full main.tf example

Here is the complete main.tf you should see once you completed this guide.

  1. provider "google" {
  2.   version = "~> 2.0"
  3.   region  = "us-west1"
  4.   alias   = "master"
  5. }
  7. provider "google" {
  8.   version = "~> 2.0"
  9.   region  = "us-east1"
  10.   alias   = "us-east1"
  11. }
  13. # Used to determine your public IP for forwarding rules
  14. data "http" "whatismyip" {
  15.   url = "http://whatismyip.akamai.com/"
  16. }
  18. // lets define variables which are shared between all regions
  19. locals {
  20.   ssh_public_key_file = "~/.ssh/id_rsa.pub"
  21.   cluster_name        = "my-dcos-demo"
  22.   admin_ips           = ["${data.http.whatismyip.body}/32"]
  24.   region_networks = {
  25.     // dont use 172.17/26 as its used by docker.
  26.     "master"   = "172.16.0.0/16" // this is the default
  27.     "us-east1" = "10.128.0.0/16"
  28.   }
  29. }
  31. module "dcos" {
  32.   source  = "dcos-terraform/dcos/gcp"
  33.   version = "~> 0.2.0"
  35.   providers = {
  36.     google = "google.master"
  37.   }
  39.   cluster_name        = "${local.cluster_name}"
  40.   ssh_public_key_file = "${local.ssh_public_key_file}"
  41.   admin_ips           = ["${local.admin_ips}"]
  42.   subnet_range        = "${local.region_networks["master"]}"
  44.   num_masters        = 3
  45.   num_private_agents = 2
  46.   num_public_agents  = 1
  48.   dcos_version = "1.13.3"
  50.   dcos_variant              = "ee"
  51.   dcos_license_key_contents = "${file("./license.txt")}"
  53.   # Make sure to set your credentials if you do not want the default EE
  54.   # dcos_superuser_username      = "superuser-name"
  55.   # dcos_superuser_password_hash = "${file("./dcos_superuser_password_hash.sha512")}"
  57.   dcos_instance_os = "centos_7"
  59.   accepted_internal_networks = "${values(local.region_networks)}"
  60.   additional_private_agent_ips = ["${module.dcos-use1.private_agents.private_ips}"]
  61. }
  63. output "masters-ips" {
  64.   value = "${module.dcos.masters-ips}"
  65. }
  67. output "cluster-address" {
  68.   value = "${module.dcos.masters-loadbalancer}"
  69. }
  71. output "public-agents-loadbalancer" {
  72.   value = "${module.dcos.public-agents-loadbalancer}"
  73. }
  75. module "dcos-use1" {
  76.   source  = "dcos-terraform/infrastructure/gcp"
  77.   version = "~> 0.2.0"
  79.   providers = {
  80.     google = "google.us-east1"
  81.   }
  83.   admin_ips   = ["${local.admin_ips}"]
  84.   name_prefix = "use1"
  86.   cluster_name               = "${local.cluster_name}"
  87.   accepted_internal_networks = "${values(local.region_networks)}"
  89.   num_bootstrap      = 0
  90.   num_masters        = 0
  91.   num_private_agents = 1
  92.   num_public_agents  = 0
  94.   lb_disable_public_agents = true
  95.   lb_disable_masters       = true
  97.   ssh_public_key_file = "${local.ssh_public_key_file}"
  98.   subnet_range        = "${local.region_networks["us-east1"]}"
  99. }
  101. module "network-connection-master-use1" {
  102.   source  = "dcos-terraform/network-peering/gcp"
  103.   version = "~> 0.2.0"
  105.   providers = {
  106.     google.local  = "google.master"
  107.     google.remote = "google.us-east1"
  108.   }
  110.   cluster_name             = "${local.cluster_name}"
  111.   local_network_name       = "master"
  112.   local_network_self_link  = "${module.dcos.infrastructure.network_self_link}"
  113.   remote_network_name      = "use1"
  114.   remote_network_self_link = "${module.dcos-use1.network_self_link}"
  115. }