Federation Between VMs and Kubernetes

    This topic requires familiarity with Mesh Gateways and .

    Consul datacenters running on non-kubernetes platforms like VMs or bare metal can be federated with Kubernetes datacenters. Just like with Kubernetes, one datacenter must be the primary.

    If your primary datacenter is running on Kubernetes, use the Helm config from the section to install Consul.

    Once installed on Kubernetes, and with the resource created, you’ll need to export the following information from the primary Kubernetes cluster:

    • Certificate authority cert and key (in order to create SSL certs for VMs)
    • External addresses of Kubernetes mesh gateways
    • Replication ACL token
    • Gossip encryption key

    The following sections detail how to export this data.

    1. Retrieve the certificate authority cert:

    2. And the certificate authority signing key:

      1. kubectl get secrets/consul-ca-key --template='{{index .data "tls.key" | base64decode }}' > consul-agent-ca-key.pem

    3. With the consul-agent-ca.pem and consul-agent-ca-key.pem files you can create certificates for your servers and clients running on VMs that share the same certificate authority as your Kubernetes servers.

      You can use the consul tls commands to generate those certificates:

      1. # NOTE: consul-agent-ca.pem and consul-agent-ca-key.pem must be in the current
      2. # directory.
      3. $ consul tls cert create -server -dc=vm-dc -node <node_name>
      4. ==> WARNING: Server Certificates grants authority to become a
      5.     server and access all state in the cluster including root keys
      6.     and all ACL tokens. Do not distribute them to production hosts
      7.     that are not server nodes. Store them as securely as CA keys.
      8. ==> Using consul-agent-ca.pem and consul-agent-ca-key.pem
      9. ==> Saved vm-dc-server-consul-0.pem
      10. ==> Saved vm-dc-server-consul-0-key.pem

      Note the -node option in the above command. This should be same as the node name of the . This is a requirement for Consul Federation to work. Alternatively, if you plan to use the same certificate and key pair on all your Consul server nodes, or you don’t know the nodename in advance, use -node "*" instead. Not satisfying this requirement would result in the following error in the Consul Server logs: [ERROR] agent.server.rpc: TLS handshake failed: conn=from= error="remote error: tls: bad certificate"

      See the help for output of consul tls cert create -h to see more options for generating server certificates.

    4. These certificates can be used in your server config file:

      1. cert_file = "vm-dc-server-consul-0.pem"
      2. key_file = "vm-dc-server-consul-0-key.pem"
      3. ca_file = "consul-agent-ca.pem"

    5. For clients, you can generate TLS certs with:

      1. $ consul tls cert create -client
      2. ==> Using consul-agent-ca.pem and consul-agent-ca-key.pem
      3. ==> Saved dc1-client-consul-0.pem
      4. ==> Saved dc1-client-consul-0-key.pem

      Or use the feature.

    Retrieve the WAN addresses of the mesh gateways:

    In this example, the addresses are the same because both mesh gateway pods are fronted by the same Kubernetes load balancer.

    These addresses will be used in the server config for the primary_gateways setting:

    1. primary_gateways = ["1.2.3.4:443"]

    If ACLs are enabled, you’ll also need the replication ACL token:

    1. $ kubectl get secrets/consul-acl-replication-acl-token --template='{{.data.token}}'
    2. e7924dd1-dc3f-f644-da54-81a73ba0a178

    This token will be used in the server config for the replication token.

    1. acls {
    2.     replication = "e7924dd1-dc3f-f644-da54-81a73ba0a178"
    3.   }
    4. }

    NOTE: You’ll also need to set up additional ACL tokens as needed by the ACL system. See tutorial Secure Consul with Access Control Lists (ACLs) for more information.

    If gossip encryption is enabled, you’ll need the key as well. The command to retrieve the key will depend on which Kubernetes secret you’ve stored it in.

    This key will be used in server and client configs for the encrypt setting:

    1. encrypt = "uF+GsbI66cuWU21kiXLze5JLEX5j4iDFlDTb0ZWNpDI="

    A final example server config file might look like:

    If you’re running your primary datacenter on VMs then you’ll need to manually construct the in order to federate Kubernetes clusters as secondaries.

    Your VM cluster must be running mesh gateways, and have mesh gateway WAN federation enabled. See WAN Federation via Mesh Gateways.

    1. The root certificate authority cert placed in .

    2. The root certificate authority key placed in consul-agent-ca-key.pem.

    3. The IP addresses of the mesh gateways running in your VM datacenter. These must be routable from the Kubernetes cluster.

    4. If ACLs are enabled you must create an ACL replication token with the following rules:

      1. acl = "write"
      2. operator = "write"
      3. agent_prefix "" {
      4.   policy = "read"
      5. }
      6. node_prefix "" {
      7.   policy = "write"
      8. }
      9. service_prefix "" {
      10.   policy = "read"
      11.   intentions = "read"
      12. }

      This token is used for ACL replication and for automatic ACL management in Kubernetes.

      If you’re running Consul Enterprise you’ll need the rules:

      1. operator = "write"
      2. agent_prefix "" {
      3.   policy = "read"
      4. }
      5. node_prefix "" {
      6.   policy = "write"
      7. }
      8. namespace_prefix "" {
      9.   acl = "write"
      10.   service_prefix "" {
      11.     policy = "read"
      12.     intentions = "read"
      13.   }
      14. }

    5. If gossip encryption is enabled, you’ll need the key.

    With that data ready, you can create the Kubernetes federation secret:

    1. kubectl create secret generic consul-federation \
    2.     --from-literal=caCert=$(cat consul-agent-ca.pem) \
    3.     --from-literal=caKey=$(cat consul-agent-ca-key.pem)
    4.     # If ACLs are enabled uncomment.
    5.     # If using gossip encryption uncomment.
    6.     # --from-literal=gossipEncryptionKey="<your gossip encryption key>"

    Then use the following Helm config file:

    1. global:
    2.   name: consul
    4.   tls:
    5.     enabled: true
    6.     caCert:
    7.       secretName: consul-federation
    8.       secretKey: caCert
    9.     caKey:
    10.       secretName: consul-federation
    11.       secretKey: caKey
    13.   # Delete this acls section if ACLs are disabled.
    14.   acls:
    15.     manageSystemACLs: true
    16.     replicationToken:
    17.       secretName: consul-federation
    18.       secretKey: replicationToken
    20.   federation:
    21.     enabled: true
    23.   # Delete this gossipEncryption section if gossip encryption is disabled.
    24.   gossipEncryption:
    25.     secretName: consul-federation
    26.     secretKey: gossipEncryptionKey
    28. connectInject:
    29.   enabled: true
    30. controller:
    31.   enabled: true
    32. meshGateway:
    33.   enabled: true
    34. server:
    35.   extraConfig: |
    36.     {
    37.       "primary_datacenter": "<your VM datacenter name>",
    38.     }

    NOTE: You must fill out the section with the datacenter name of your primary datacenter running on VMs and with the IPs of your mesh gateways running on VMs.

    With your config file ready to go, follow our to install Consul on your secondary cluster(s).

    After installation, if you’re using consul-helm 0.30.0+, create the ProxyDefaults resource to allow traffic between datacenters.

    In both cases (Kubernetes as primary or secondary), after installation, follow the section to verify that federation is working as expected.