Crear Cluster AKS en Azure con Terraform

rokitoh Azure, Cloud, Cluster, Devops, kubernetes

En este artículo, se explicará cómo desplegar un servicio de AKS (Azure Kubernetes Service) en Azure utilizando Terraform.

AKS es un servicio de Azure que permite a los usuarios desplegar, administrar y escalar aplicaciones en contenedores utilizando Kubernetes.

Requisitos previos

Antes de comenzar con el despliegue de AKS en Azure mediante Terraform, es necesario contar con los siguientes elementos:

  • Cuenta de Azure activa
  • Azure CLI instalado en la máquina local
  • Terraform instalado en la máquina local
  • Conocimiento básico de Kubernetes y Terraform

Paso 1: Crear Service Principal

Creamos un Service Principal en Azure utilizando el comando «az «, Para ello lo hacemos de la siguiente forma:

  1. Abre la línea de comandos de Azure o una terminal en tu equipo y asegúrate de haber iniciado sesión en tu cuenta de Azure mediante el comando «az login».
  2. Escribe el comando «az ad sp create-for-rbac –name <nombre_del_service_principal>» y reemplaza «<nombre_del_service_principal>» con el nombre que deseas asignar al Service Principal.

Por ejemplo, si deseas crear un Service Principal con el nombre «mi-sp», el comando se vería así:

az ad sp create-for-rbac --name myAKSClusterServicePrincipal
  1. El comando generará una salida similar a esta:
{
  "appId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "displayName": "myAKSClusterServicePrincipal",
  "name": "http://myAKSClusterServicePrincipal,
  "password": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "tenant": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}

Donde:

  • «appId» es el identificador de la aplicación del Service Principal (también conocido como «client ID»).
  • «displayName» es el nombre que has asignado al Service Principal.
  • «name» es la URL que representa al Service Principal.
  • «password» es la contraseña que has generado para el Service Principal (también conocido como «client secret»).
  • «tenant» es el identificador de la organización de Azure que ha creado el Service Principal.

Una vez que se ha creado el Service Principal, es necesario generar un ID secreto para poder utilizarlo para autenticar y acceder a los recursos en Azure. Este ID secreto es una clave de seguridad que se utiliza para autenticar y autorizar solicitudes de acceso a los recursos de Azure y debe ser protegido y guardado en un lugar seguro. Por lo tanto, es importante generar una clave segura y almacenarla de manera segura para evitar posibles brechas de seguridad.

az ad app credential reset --id <client_id>

Reemplazar <client_id> con el ID de cliente del Service Principal que se acaba de crear.

El comando generará una salida similar a esta:

{
  "appId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "password": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "tenant": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}

Paso 2: Crear el archivo de configuración para los «provider»

En el primer fichero de configuración llamado providers.tf configuraremos los provider

En Terraform, un «provider» es un componente que permite a Terraform interactuar con un servicio o tecnología específica, como por ejemplo Amazon Web Services (AWS), Microsoft Azure, Google Cloud Platform (GCP), o cualquier otro proveedor de servicios.

Cada proveedor de Terraform incluye una serie de recursos y datos, que se pueden usar para definir la infraestructura y configuración que se desea crear en ese servicio.

terraform {
  required_version = ">=1.0"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
  }
}

provider "azurerm" {
  features {}
}

Paso 3: Creación del archivo de configuración de Terraform

Este es un código Terraform que crea un clúster de Kubernetes en Microsoft Azure, junto con una red virtual y una subred. El clúster se configura con un perfil de Linux y un servicio principal, y se crea en un grupo de recursos llamado «Red-Orbita». Este código simplifica la creación de una infraestructura de red y un clúster de Kubernetes para una aplicación en Azure de manera automatizada.

Crea un archivo llamado «main.tf» y copia el siguiente código:

# Creación de grupo de recursos
resource "azurerm_resource_group" "RG-Red-Orbita" {
  name     = "Red-Orbita"
  location = "West Europe"
}

# Creación de red virtual
resource "azurerm_virtual_network" "VNET-Red-Orbita" {
  name                = "RedOrbita-Vnet"
  address_space       = ["10.30.0.0/24"]
  location            = azurerm_resource_group.RG-Red-Orbita.location
  resource_group_name = azurerm_resource_group.RG-Red-Orbita.name
}

# Creación de subred
resource "azurerm_subnet" "Subnet-FrontEnd" {
  name                 = "FrontEnd"
  resource_group_name  = azurerm_resource_group.RG-Red-Orbita.name
  virtual_network_name = azurerm_virtual_network.VNET-Red-Orbita.name
  address_prefixes     = ["10.30.0.0/28"]
}

resource "azurerm_kubernetes_cluster" "k8s" {
  location            = azurerm_resource_group.RG-Red-Orbita.location
  name                = var.cluster_name
  resource_group_name = azurerm_resource_group.RG-Red-Orbita.name
  dns_prefix          = var.dns_prefix
  tags                = {
    Environment = "Development"
  }

  default_node_pool {
    name       = "k8spool"
    vm_size    = "Standard_D2_v2"
    node_count = var.agent_count
  }
  linux_profile {
    admin_username = "ubuntu"

    ssh_key {
      key_data = file(var.ssh_public_key)
    }
  }
  network_profile {
    network_plugin    = "kubenet"
    load_balancer_sku = "standard"
  }
  service_principal {
    client_id     = var.aks_service_principal_app_id
    client_secret = var.aks_service_principal_client_secret
  }
}

Paso 4: Creación del archivo variables.tf

variable "agent_count" {
  default = 1
}

# The following two variable declarations are placeholder references.
# Set the values for these variable in terraform.tfvars
variable "aks_service_principal_app_id" {
  default = ""
}

variable "aks_service_principal_client_secret" {
  default = ""
}

variable "cluster_name" {
  default = "k8stest"
}

variable "dns_prefix" {
  default = "k8stest"
}

variable "ssh_public_key" {
  default = "~/.ssh/id_rsa.pub"
}

Paso 5: Creación del archivo outputs.tf

output "client_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_certificate
  sensitive = true
}

output "client_key" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_key
  sensitive = true
}

output "cluster_ca_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].cluster_ca_certificate
  sensitive = true
}

output "cluster_password" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].password
  sensitive = true
}

output "cluster_username" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].username
  sensitive = true
}

output "host" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].host
  sensitive = true
}

output "kube_config" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config_raw
  sensitive = true
}

Paso 6: Creación del archivo terraform.tfvar

Para completar la configuración de nuestra aplicación en Azure, es necesario agregar los valores del ID del Service Principal y el ID del Secret al archivo terraform.tfvar. Esto se logra mediante la asignación de los valores correspondientes a las variables «aks_service_principal_app_id» y «aks_service_principal_client_secret».

Para obtener los valores de ID del Service Principal y el ID del Secret, debemos haber completado el «Paso 1» de creación del Service Principal y su clave secreta, y anotado los valores correspondientes que se muestran en la salida del comando.

Una vez que se tienen los valores necesarios, se deben agregar al archivo terraform.tfvar en el siguiente formato:

aks_service_principal_app_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
aks_service_principal_client_secret = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

Reemplazar los valores de «xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx» con los valores correspondientes de ID del Service Principal y del ID del Secret. Con estos valores, Terraform puede autenticar y acceder a los recursos de Azure necesarios para crear y administrar el clúster de Kubernetes.

Paso 7: Desplegar cluster AKS

Nos logamos a Azure

az login
az account set -s "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

Desplegamos

 terraform init
 terraform validate
 terraform plan
 terraform apply

En caso que tengamos que importar algún estado como por ejemplo en mi caso el grupo de recurso y la vnet. Esto nos creará un fichero llamado «terraform.tfstate» el cual guarda todos los estados de los recursos importados. 

terraform import azurerm_resource_group.RG-RedOrbita  /subscriptions/XXXXXXXXXXXXXXXXXXXXXXXXXX/resourceGroups/RedOrbita

terraform import azurerm_virtual_network.VNET-Red-Orbita /subscriptions/XXXXXXXXXXXXXXXXXXXXXXXXXX/resourceGroups/RedOrbita/providers/Microsoft.Network/virtualNetworks/RedOrbita-Vnet

terraform import azurerm_subnet.Subnet-FrontEnd /subscriptions/XXXXXXXXXXXXXXXXXXXXXXXXXX/resourceGroups/RedOrbita/providers/Microsoft.Network/virtualNetworks/RedOrbita-Vnet/subnets/FrontEnd

Más información

:wq!

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *