Note:

Este tutorial requiere acceso a Oracle Cloud. Para registrarse para obtener una cuenta gratuita, consulte Introducción a la cuenta gratuita de Oracle Cloud Infrastructure.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar la práctica, sustituya estos valores por otros específicos de su entorno en la nube.

Despliegue de un cluster de Kubernetes con Terraform mediante Oracle Cloud Infrastructure Kubernetes Engine

Introducción

El despliegue de Kubernetes con Terraform en Oracle Cloud Infrastructure Kubernetes Engine (OCI Kubernetes Engine u OKE) ofrece un enfoque optimizado y escalable para gestionar aplicaciones en contenedores en la nube. OKE, un servicio de Kubernetes gestionado de Oracle Cloud Infrastructure, simplifica el despliegue, la gestión y la ampliación de los clusters de Kubernetes.

Con Terraform, una herramienta de infraestructura como código (IaC), puede automatizar el aprovisionamiento y la configuración de clusters de OKE, lo que garantiza la consistencia y la eficiencia. Esta combinación permite despliegues repetibles, control de versiones de infraestructura y actualizaciones sencillas, por lo que es ideal para equipos nativos en la nube y centrados en DevOps que buscan aprovechar el ecosistema de Oracle Cloud Infrastructure.

En este tutorial, vamos a desplegar una arquitectura de Kubernetes muy específica en OCI OKE mediante Terraform.

Vamos a desplegar los siguientes componentes:

Gateway de Internet
Gateway de NAT
Gateway de servicio
7 x subredes (privadas y públicas)
2 agrupaciones de nodos
4 nodos de trabajador (instancias)
Bastión (instancia)
Operador (Instancia)

Objetivos

Despliegue un cluster de Kubernetes con Terraform con OKE.

Requisitos

Para desplegar objetos en OCI mediante Terraform, primero debe preparar el entorno para autenticar y ejecutar scripts de Terraform. Para obtener más información, consulte Tarea 2: preparación del entorno para la autenticación y ejecución de scripts de Terraform.

Tarea 1: Clonación del repositorio con los scripts de Terraform

Clone el repositorio terraform-oci-oke desde aquí: terraform-oci-oke.
1. En el momento de escribir este tutorial, la última versión es 5.1.8.
2. Puede descargar el archivo zip completo con el repositorio completo o clonar el repositorio mediante el comando git clone.
3. Haga clic en la versión para acceder a la rama 5.1.8.
1. Tenga en cuenta que está en la rama 5.1.8.
2. Haga clic en la carpeta docs.
Haga clic en la carpeta src.
Haga clic en el archivo SUMMARY.md.
Haga clic en Introducción.
1. Tenga en cuenta que todavía está en la rama 5.1.8, otras ramas pueden contener diferentes tipos de pasos de documentación según la versión del código.
2. Tenga en cuenta que está en la página Introducción y esta página hará exactamente lo que dice el título.
En la siguiente salida, puede ver cómo utilizamos la página Introducción para crear este tutorial.
1. Ejecute el comando git clone para clonar el repositorio.
```
iwhooge@iwhooge-mac ~ % git clone https://github.com/oracle-terraform-modules/terraform-oci-oke.git tfoke
```
2. Ejecute el siguiente comando para cambiar la carpeta a la carpeta del repositorio.
3. Ejecute el siguiente comando para mostrar el contenido de la carpeta.
4. Puede ver todos los archivos del repositorio.

Cree un archivo providers.tf dentro de este directorio con el siguiente contenido.

providers.tf:

provider "oci" {
  fingerprint      = var.api_fingerprint
  private_key_path = var.api_private_key_path
  region           = var.region
  tenancy_ocid     = var.tenancy_id
  user_ocid        = var.user_id
}

provider "oci" {
  fingerprint      = var.api_fingerprint
  private_key_path = var.api_private_key_path
  region           = var.home_region
  tenancy_ocid     = var.tenancy_id
  user_ocid        = var.user_id
  alias            = "home"
}

Ejecute el siguiente comando para mostrar el contenido de la carpeta.
Tenga en cuenta que se crea el archivo providers.tf.

Ejecute el siguiente comando para inicializar Terraform y actualizar los módulos necesarios.
```
iwhooge@iwhooge-mac tfoke % terraform init --upgrade
```
Tenga en cuenta que se muestra el mensaje: Terraform se ha inicializado correctamente.

Asegúrese de que tiene la siguiente información disponible para crear el archivo terraform.tfvars. Esta información se puede recuperar mediante los siguientes pasos mencionados aquí: Tarea 2: Preparar el entorno para la autenticación y ejecutar scripts de Terraform.

OCID de arrendamiento	ocid1.tenancy.oc1..aaaaaaaaXXX
OCID de usuario	ocid1.user.oc1..aaaaaaaaXXX
Huella	30:XXX
Región	me-abudhabi-1
Ruta de clave privada	~/.oci/4-4-2023-rsa-key.pem
OCID de compartimento	ocid1.compartment.oc1..aaaaaaaaXXX

Necesitamos crear un archivo terraform.tfvars dentro de este directorio con el siguiente contenido.

terraform.tfvars:

# Identity and access parameters
api_fingerprint      = "30:XXX"
api_private_key_path = "~/.oci/4-4-2023-rsa-key.pem"

home_region = "me-abudhabi-1"
region      = "me-abudhabi-1"
tenancy_id  = "ocid1.tenancy.oc1..aaaaaaaaXXX"
user_id     = "ocid1.user.oc1..aaaaaaaaXXX"

# general oci parameters
compartment_id = "ocid1.compartment.oc1..aaaaaaaaXXX"
timezone       = "Australia/Sydney"

# ssh keys
ssh_private_key_path = "~/.ssh/id_rsa"
ssh_public_key_path  = "~/.ssh/id_rsa.pub"

# networking
create_vcn               = true
assign_dns               = true
lockdown_default_seclist = true
vcn_cidrs                = ["10.0.0.0/16"]
vcn_dns_label            = "oke"
vcn_name                 = "oke"

# Subnets
subnets = {
  bastion  = { newbits = 13, netnum = 0, dns_label = "bastion", create="always" }
  operator = { newbits = 13, netnum = 1, dns_label = "operator", create="always" }
  cp       = { newbits = 13, netnum = 2, dns_label = "cp", create="always" }
  int_lb   = { newbits = 11, netnum = 16, dns_label = "ilb", create="always" }
  pub_lb   = { newbits = 11, netnum = 17, dns_label = "plb", create="always" }
  workers  = { newbits = 2, netnum = 1, dns_label = "workers", create="always" }
  pods     = { newbits = 2, netnum = 2, dns_label = "pods", create="always" }
}

# bastion
create_bastion           = true
bastion_allowed_cidrs    = ["0.0.0.0/0"]
bastion_user             = "opc"

# operator
create_operator                = true
operator_install_k9s           = true


# iam
create_iam_operator_policy   = "always"
create_iam_resources         = true

create_iam_tag_namespace = false // true/*false
create_iam_defined_tags  = false // true/*false
tag_namespace            = "oke"
use_defined_tags         = false // true/*false

# cluster
create_cluster     = true
cluster_name       = "oke"
cni_type           = "flannel"
kubernetes_version = "v1.29.1"
pods_cidr          = "10.244.0.0/16"
services_cidr      = "10.96.0.0/16"

# Worker pool defaults
worker_pool_size = 0
worker_pool_mode = "node-pool"

# Worker defaults
await_node_readiness     = "none"

worker_pools = {
  np1 = {
    shape              = "VM.Standard.E4.Flex",
    ocpus              = 2,
    memory             = 32,
    size               = 1,
    boot_volume_size   = 50,
    kubernetes_version = "v1.29.1"
  }
  np2 = {
    shape            = "VM.Standard.E4.Flex",
    ocpus            = 2,
    memory           = 32,
    size             = 3,
    boot_volume_size = 150,
    kubernetes_version = "v1.30.1"
  }
}

# Security
allow_node_port_access       = false
allow_worker_internet_access = true
allow_worker_ssh_access      = true
control_plane_allowed_cidrs  = ["0.0.0.0/0"]
control_plane_is_public      = false
load_balancers               = "both"
preferred_load_balancer      = "public"

Ejecute el siguiente comando para mostrar el contenido de la carpeta.
Tenga en cuenta que se crea el archivo terraform.tfvars.

Tarea 2: Ejecución de la aplicación de Terraform y creación de un cluster de OKE con los recursos necesarios (VCN, subredes, etc.)

Ejecute el siguiente comando para planificar el despliegue del cluster de Kubernetes en OKE mediante Terraform.
```
iwhooge@iwhooge-mac tfoke % terraform plan
```
1. Tenga en cuenta que este código de Terraform desplegará 77 objetos.
2. Ejecute el comando terraform apply.
Ejecute el siguiente comando para aplicar el despliegue de cluster de Kubernetes en OKE mediante Terraform.
```
iwhooge@iwhooge-mac tfoke % terraform apply
```
1. Tenga en cuenta que este código de Terraform desplegará 77 objetos.
2. Introduzca yes para continuar con el despliegue.
Cuando haya terminado el despliegue, verá un mensaje que indica que la aplicación ha finalizado.

Observe la salida que se ha proporcionado con información útil que puede necesitar para su referencia.

Salidas:

apiserver_private_host = "10.0.0.22"

availability_domains = tomap({

  "1" = "cAtJ:ME-ABUDHABI-1-AD-1"

})

bastion_id = "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkxxxxxx5chephxjadkxqa2ekxksb5gokj4q"

bastion_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaxxxxxxxxxxxy5qm22odw7by37h77ki6cosoqd7pzwq"

bastion_public_ip = "129.151.149.237"

bastion_subnet_cidr = "10.0.0.0/29"

bastion_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaxxxxxxxxxxxxxxxxmyzp6f2czibfr6534evfkt7m2a"

cluster_endpoints = tomap({

  "kubernetes" = ""

  "private_endpoint" = "10.0.0.22:6443"

  "public_endpoint" = ""

  "vcn_hostname_endpoint" = "cbyedhyevbq.cp.oke.oraclevcn.com:6443"

})

cluster_id = "ocid1.cluster.oc1.me-abudhabi-1.aaaaaaaxxxxxxxxxxxxx57gz5q26hmpzkbcbyedhyevbq"

control_plane_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaavxvgoewcgxxxxxxxxxxxxx6psycdz6zz5gaf6re4kcxa"

control_plane_subnet_cidr = "10.0.0.16/29"

control_plane_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaajvvpdmuixxxxxxxxxxxjkpx77hqu3v2s4qilnp56a"

dynamic_group_ids = tolist([

  "ocid1.dynamicgroup.oc1..aaaaaaaafsikvwgexxxxxxxxx5tx2u4c2s2eic4sslwyabva",

])

ig_route_table_id = "ocid1.routetable.oc1.me-abudhabi-1.aaaaaaaalxxxxxxxxxxxxxxcyzrl2af4ihrkhcjttu2w7aq"

int_lb_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaanwppaafc7fyiwcoyhjxxxxxxxxxxxxxxxxx6a6752l7547gxg7ea"

int_lb_subnet_cidr = "10.0.2.0/27"

int_lb_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaawo5xmcwwbzk3gxxxxxxxxxxxxxxxxxxjjfllbvsdauaq"

lpg_all_attributes = {}

nat_route_table_id = "ocid1.routetable.oc1.me-abudhabi-1.aaaaaaaapqn3uqtszdcxxxxxxxxxxxxxxxxxliwveow232xgffigq"

operator_id = "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac5exxxxxxxxxxxxxxxxxxxxxxxrfdxsjdfzmq56jja"

operator_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaao5kh3z3eaf4zhbtxixxxxxxxxxxxxxxxxxxxxxevyds3cbrjqzthv5ja"

operator_private_ip = "10.0.0.14"

operator_subnet_cidr = "10.0.0.8/29"

operator_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaa6vnirazbox2edmtnxrzhxxxxxxxxxxxxxxxxxxxishk7556iw6zyq"

pod_subnet_cidr = "10.0.128.0/18"

pod_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaasfnwg3lnyphk5h275r46ksi3xxxxxxxxxxxxxxxxxxxxxxxqz25iwkcinxa"

policy_statements = tolist([

  "Allow dynamic-group oke-operator-lccwyk to MANAGE clusters in compartment id ocid1.compartment.oc1..aaaaaaaa323ijv54zwkwbz2hhr2nnqoywlpxxxxxxxxxxxxxxxxxxxxxxxtecokaq4h4a",

])

pub_lb_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaae5stez5u26g6x75dy5nf72mfcixxxxxxxxxxxxxxxxxxxxxxxx2nwkwv5nkaa"

pub_lb_subnet_cidr = "10.0.2.32/27"

pub_lb_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaagr5j2l6tu3rmroejg6t4nrixxxxxxxxxx6oar6xcirvq"

ssh_to_bastion = "ssh -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx"

ssh_to_operator = "ssh -o ProxyCommand='ssh -W %h:%p -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx' -i ~/.ssh/id_rsa opc@10.0.0.14"

state_id = "lccwyk"

vcn_id = "ocid1.vcn.oc1.me-abudhabi-1.amaaaaaapkbrwsaatndqrw3xq7e7krqfxxxxxxxxxxxxxxxpywz4qvhida"

worker_nsg_id = "ocid1.networksecuritygroup.oc1.me-abudhabi-1.aaaaaaaazbpfavygiv4xy3khfi7cxunixxxxxxxxxxxxxxxxjvsm6jqtja"

worker_pool_ids = {

  "np1" = "ocid1.nodepool.oc1.me-abudhabi-1.aaaaaaaauo57ekyoiiaif25gq7uwrpxxxxxxxxxxxxxxpsnygeam7t2wa"

  "np2" = "ocid1.nodepool.oc1.me-abudhabi-1.aaaaaaaa7423cp6zyntxwxokol3kmdxxxxxxxxxxxxx3wnayv2xq6nyq"

}

worker_pool_ips = {

  "np1" = {

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac3t3smjsyxjgen4zqjpxxxxxxxxxxxxx663igu7cznla" = "10.0.90.37"

  }

  "np2" = {

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsac2eayropnzgazrxxxxxxxxxxxxxxxxpiykrq4r5pbga" = "10.0.125.238"

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsace4aup47ukjcedxxxxxxxxxxxxxxxxxx2hdxbsyiitva" = "10.0.92.136"

    "ocid1.instance.oc1.me-abudhabi-1.anqxkljrpkbrwsacojjri4b7qsaxxxxxxxxxxxxxxxxxnarf75ejv7a2a" = "10.0.111.157"

  }

}

worker_subnet_cidr = "10.0.64.0/18"

worker_subnet_id = "ocid1.subnet.oc1.me-abudhabi-1.aaaaaaaarrnazbrmwbiyl3ljmdxhgmxxxxxxxxxxxxxxxxxxxv3wtgmiucnsa"

iwhooge@iwhooge-mac tfoke %

Tarea 3: Confirmación del despliegue de Terraform en la consola de OCI

Navegue a la consola de OCI y confirme los siguientes despliegues de Terraform.

Cluster de OCI Kubernetes Engine
- Vaya a la consola de OCI.
  1. Vaya a Servicios para desarrolladores y haga clic en Clusters de Kubernetes (OKE).
  2. Haga clic en el cluster de Kubernetes de clave creado en la tarea 2.
- Desplazar hacia abajo.
  1. Haga clic en Pools de nodos.
  2. Haga clic en el pool de nodos np1.
- Desplazar hacia abajo.
- Tenga en cuenta que hay un nodo de trabajador en el pool de nodos np1.
- Vaya a la página anterior y haga clic en el pool de nodos np2.
- Desplazar hacia abajo.
- Tenga en cuenta que hay tres nodos de trabajador en el pool de nodos np2.
Instancias
- Vaya a la consola de OCI.
  1. Vaya a Compute y haga clic en Instances.
  2. Revise los cuatro nodos de trabajador del cluster de Kubernetes.
  3. Revise el operador del cluster de Kubernetes.
  4. Revise que el host bastion pertenece al cluster de Kubernetes.
Red virtual en la nube
- Vaya a la consola de OCI, vaya a Networking, Virtual Cloud Networks y haga clic en la VCN de oke.
- Haga clic en Subredes y podrá ver las siete subredes del cluster de Kubernetes.
- En la siguiente imagen se ilustra lo que hemos creado hasta ahora con el script de Terraform.

Tarea 4: Uso del bastión y el operador para comprobar la conectividad

En la salida encontrará algunos comandos para conectarse al entorno de Kubernetes cuando termine el despliegue de Terraform.

Ejecute el siguiente comando para conectarse al host bastión.
```
ssh_to_bastion = "ssh -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx"
```

Ejecute el siguiente comando para conectarse al operador de Kubernetes mediante el host bastión.

ssh_to_operator = "ssh -o ProxyCommand='ssh -W %h:%p -i ~/.ssh/id_rsa opc@129.xxx.xxx.xxx' -i ~/.ssh/id_rsa opc@10.0.0.14"

Gestionaremos el cluster de Kubernetes desde el operador. Introduzca yes dos veces y ejecute el comando kubectl get nodes para obtener los nodos de trabajador de Kubernetes.

Para facilitar las conexiones SSH, agregue los siguientes comandos adicionales en el archivo ~/.ssh/config.

Host bastion47
    HostName 129.xxx.xxx.xxx
    user opc
    IdentityFile ~/.ssh/id_rsa
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Host operator47
    HostName 10.0.0.14
    user opc
    IdentityFile ~/.ssh/id_rsa
    ProxyJump bastion47
    UserKnownHostsFile /dev/null
    StrictHostKeyChecking=no
    TCPKeepAlive=yes
    ServerAliveInterval=50

Después de agregar el siguiente contenido al archivo ~/.ssh/config, podrá utilizar nombres simples en los comandos SSH.

iwhooge@iwhooge-mac tfoke % ssh operator47

Tarea 5: Supresión del cluster de Kubernetes mediante Terraform

Ejecute el comando terraform destroy para suprimir el cluster de Kubernetes en OKE.
```
iwhooge@iwhooge-mac tfoke % terraform destroy
```
Introduzca yes.

Cuando termine el proceso de destrucción, verá un mensaje que indica que se ha completado la destrucción.

Pasos Siguientes

El despliegue de un cluster de Kubernetes en OCI Kubernetes Engine mediante Terraform proporciona una solución eficiente, automatizada y escalable para gestionar aplicaciones en contenedores en la nube.

Al aprovechar las capacidades IaC de Terraform, se asegura de que los clusters de Kubernetes se desplieguen de forma consistente y se puedan mantener o actualizar fácilmente con el tiempo.

Esta integración optimiza el proceso, lo que permite un mejor control de versiones, escalado automatizado y una configuración de infraestructura repetible. Tanto si gestiona un solo cluster como si se escala en distintos entornos, este enfoque permite a los equipos gestionar sus cargas de trabajo de Kubernetes con fiabilidad y facilidad en Oracle Cloud Infrastructure.

Agradecimientos

Autor: Iwan Hoogendoorn (especialista en red de OCI)

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de formación gratuita en el canal YouTube de Oracle Learning. Además, visita education.oracle.com/learning-explorer para convertirte en un Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

Deploy a Kubernetes Cluster with Terraform using Oracle Cloud Infrastructure Kubernetes Engine

G18100-01

October 2024

Oracle y/o sus filiales.