Creación de un clúster de Kubernetes con Azure Kubernetes Service mediante Terraform

Artículo
12/03/2021
Tiempo de lectura: 9 minutos

Azure Kubernetes Service (AKS) administra el entorno hospedado de Kubernetes. Azure Kubernetes Service permite implementar y administrar aplicaciones en contenedores sin necesidad de tener conocimientos de orquestación de contenedores. También permite realizar muchas operaciones de mantenimiento comunes sin desconectar la aplicación. Entre estas operaciones se incluyen el aprovisionamiento, la actualización y el escalado de recursos a petición.

En este artículo aprenderá a:

Uso de HCL (HashiCorp Language) para definir un clúster de Kubernetes

Uso de Terraform y AKS para crear un clúster de Kubernetes

Utilice la herramienta kubectl para probar la disponibilidad de un clúster de Kubernetes

1. Configurar su entorno

Suscripción de Azure: Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Configuración de Terraform: si aún no lo ha hecho, configure Terraform con una de las siguientes opciones:

Entidad de servicio de Azure: si aún no tiene una entidad de servicio, cree una. Anote los valores de appId, displayName, password y tenant.

2. Creación de un par de claves SSH

En el ejemplo de este artículo se usa un par de claves SSH para validar el usuario en la máquina virtual.

Genere un par de claves SSH siguiendo uno de los siguientes artículos en función de su entorno:

3. Creación de la estructura de directorios

El primer paso es crear el directorio que contenga los archivos de configuración de Terraform para el ejercicio.

Abra un símbolo de línea de comandos desde el que pueda ejecutar comandos de Terraform.
Cree un directorio llamado terraform-aks-k8s.
Cambie los directorios al nuevo directorio:

4. Declaración del proveedor de Azure

Un archivo de configuración de Terraform se inicia con la especificación del proveedor. Al usar Azure, especifique el proveedor de Azure (azurerm) en el bloque .

terraform {
  required_providers {
    azurerm = {
      source = "hashicorp/azurerm"
      version = "~>2.0"
    }
  }
}
provider "azurerm" {
  features {}
}
resource "azurerm_resource_group" "rg" {
  name = "<resource_group_name>"
  location = "<location>"
}

# Your Terraform code goes here...

Puntos clave:

Aunque el atributo version es opcional, HashiCorp recomienda anclarlo a una versión determinada del proveedor.
Si usa la versión 1.x del proveedor de Azure, no se permite el bloque features.
Si usa la versión 2.x del proveedor de Azure, se requiere el bloque features.
La declaración de recursos azurerm_resource_group tiene dos argumentos: y . Establezca los marcadores de posición en los valores adecuados para su entorno.
El valor con nombre local de para el grupo de recursos se usa en los artículos de procedimientos y artículos al hacer referencia al grupo de recursos. Es independiente del nombre del grupo de recursos y solo hace referencia al nombre de la variable en el código. Si cambia este valor en la definición del grupo de recursos, cámbielo también en el código que hace referencia a él.

5. Definición de un clúster de Kubernetes

Cree el archivo de configuración de Terraform que declara los recursos para el clúster de Kubernetes.

Cree un archivo llamado k8s.tf.

Inserte el código siguiente en el nuevo archivo:

resource "azurerm_resource_group" "k8s" {
    name     = var.resource_group_name
    location = var.location
}

resource "random_id" "log_analytics_workspace_name_suffix" {
    byte_length = 8
}

resource "azurerm_log_analytics_workspace" "test" {
    # The WorkSpace name has to be unique across the whole of azure, not just the current subscription/tenant.
    name                = "${var.log_analytics_workspace_name}-${random_id.log_analytics_workspace_name_suffix.dec}"
    location            = var.log_analytics_workspace_location
    resource_group_name = azurerm_resource_group.k8s.name
    sku                 = var.log_analytics_workspace_sku
}

resource "azurerm_log_analytics_solution" "test" {
    solution_name         = "ContainerInsights"
    location              = azurerm_log_analytics_workspace.test.location
    resource_group_name   = azurerm_resource_group.k8s.name
    workspace_resource_id = azurerm_log_analytics_workspace.test.id
    workspace_name        = azurerm_log_analytics_workspace.test.name

    plan {
        publisher = "Microsoft"
        product   = "OMSGallery/ContainerInsights"
    }
}

resource "azurerm_kubernetes_cluster" "k8s" {
    name                = var.cluster_name
    location            = azurerm_resource_group.k8s.location
    resource_group_name = azurerm_resource_group.k8s.name
    dns_prefix          = var.dns_prefix

    linux_profile {
        admin_username = "ubuntu"

        ssh_key {
            key_data = file(var.ssh_public_key)
        }
    }

    default_node_pool {
        name            = "agentpool"
        node_count      = var.agent_count
        vm_size         = "Standard_D2_v2"
    }

    service_principal {
        client_id     = var.client_id
        client_secret = var.client_secret
    }

    addon_profile {
        oms_agent {
        enabled                    = true
        log_analytics_workspace_id = azurerm_log_analytics_workspace.test.id
        }
    }

    network_profile {
        load_balancer_sku = "Standard"
        network_plugin = "kubenet"
    }

    tags = {
        Environment = "Development"
    }
}

El código anterior establece el nombre del clúster, la ubicación y el nombre del grupo de recursos. También se establece el prefijo del nombre de dominio completo (FQDN). El nombre de dominio completo se usa para acceder al clúster.

El registro linux_profile permite configurar las opciones que permiten iniciar sesión en los nodos de trabajo mediante SSH.

Con AKS, solo se paga por los nodos de trabajo. El registro default_node_pool configura los detalles de estos nodos de trabajo. El registro default_node_pool record incluye el número de nodos de trabajo que se van a crear y el tipo de estos. Si necesita escalar o reducir verticalmente el clúster en el futuro, modifique el valor de count en este registro.

6. Declaración de las variables

Cree un archivo llamado variables.tf que contenga las variables del proyecto e inserte el código siguiente:

variable "client_id" {}
variable "client_secret" {}

variable "agent_count" {
    default = 3
}

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

variable "dns_prefix" {
    default = "k8stest"
}

variable cluster_name {
    default = "k8stest"
}

variable resource_group_name {
    default = "azure-k8stest"
}

variable location {
    default = "Central US"
}

variable log_analytics_workspace_name {
    default = "testLogAnalyticsWorkspaceName"
}

# refer https://azure.microsoft.com/global-infrastructure/services/?products=monitor for log analytics available regions
variable log_analytics_workspace_location {
    default = "eastus"
}

# refer https://azure.microsoft.com/pricing/details/monitor/ for log analytics pricing 
variable log_analytics_workspace_sku {
    default = "PerGB2018"
}

7. Creación de un archivo de salida de Terraform

Las salidas de Terraform permiten definir valores que se resaltarán al usuario cuando Terraform aplique un plan y se pueden consultar mediante el comando . En esta sección, va a crear un archivo de salida que permita el acceso al clúster con kubectl.

Cree un archivo llamado output.tf.

Inserte el código siguiente en el nuevo archivo:

output "client_key" {
    value = azurerm_kubernetes_cluster.k8s.kube_config.0.client_key
}

output "client_certificate" {
    value = azurerm_kubernetes_cluster.k8s.kube_config.0.client_certificate
}

output "cluster_ca_certificate" {
    value = azurerm_kubernetes_cluster.k8s.kube_config.0.cluster_ca_certificate
}

output "cluster_username" {
    value = azurerm_kubernetes_cluster.k8s.kube_config.0.username
}

output "cluster_password" {
    value = azurerm_kubernetes_cluster.k8s.kube_config.0.password
}

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

output "host" {
    value = azurerm_kubernetes_cluster.k8s.kube_config.0.host
}

8. Configuración del almacenamiento de Azure para almacenar el estado de Terraform

Terraform realiza un seguimiento del estado de manera local a través del archivo terraform.tfstate. Este patrón funciona bien en un entorno de persona único. En un entorno de varias personas, Azure Storage se usa para realizar un seguimiento del estado.

En esta sección, verá cómo se realizan las siguientes tareas:

Recuperar la información de la cuenta de almacenamiento (nombre y clave de la cuenta).
Cree un contenedor de almacenamiento en el que se almacenará la información de estado de Terraform.

En Azure Portal, seleccione Todos los servicios en el menú de la izquierda.
Seleccione Cuentas de almacenamiento.
En la pestaña Cuentas de almacenamiento, seleccione el nombre de la cuenta de almacenamiento en la que Terraform va a almacenar el estado. Por ejemplo, puede utilizar la cuenta de almacenamiento creada cuando abrió Cloud Shell por primera vez. El nombre de cuenta de almacenamiento creada por Cloud Shell normalmente comienza por cs seguido de una cadena aleatoria de números y letras. Anote la cuenta de almacenamiento que seleccione. Este valor lo necesitará más adelante.
En la pestaña Cuenta de almacenamiento, seleccione Claves de acceso.
Anote el valor de la clave1clave. (Al seleccionar el icono a la derecha de la clave, se copia el valor al portapapeles).

Cree un contenedor en su cuenta de Azure Storage. Reemplace los marcadores de posición por valores adecuados para su entorno.

az storage container create -n tfstate --account-name <YourAzureStorageAccountName> --account-key <YourAzureStorageAccountKey>

9. Creación del clúster de Kubernetes

En esta sección, puede ver cómo usar el comando terraform init para crear los recursos definidos en los archivos de configuración que creó en las secciones anteriores.

En Cloud Shell, inicialice Terraform. Reemplace los marcadores de posición por valores adecuados para su entorno.

terraform init -backend-config="storage_account_name=<YourAzureStorageAccountName>" -backend-config="container_name=tfstate" -backend-config="access_key=<YourStorageAccountAccessKey>" -backend-config="key=codelab.microsoft.tfstate"

El comando terraform init muestra el éxito de inicializar el back-end y el complemento del proveedor:

Ejemplo de resultados de

Exporte las credenciales de la entidad de servicio. Reemplace los marcadores de posición por valores adecuados de su entidad de servicio.
```
export TF_VAR_client_id=<service-principal-appid>
export TF_VAR_client_secret=<service-principal-password>
```
Ejecute el comando terraform plan para crear el plan de Terraform que define los elementos de infraestructura.
```
terraform plan -out out.plan
```
El comando terraform plan muestra los recursos que se crearán cuando ejecute el comando terraform apply:
Ejecute el comando terraform apply para aplicar el plan para crear el clúster de Kubernetes. El proceso para crear un clúster de Kubernetes puede tardar varios minutos, dado como resultado el agotamiento del tiempo de espera de la sesión de Cloud Shell. Si la sesión de Cloud Shell agota su tiempo de espera, puede seguir los pasos de la sección "Recuperación de un tiempo de espera de Cloud Shell" para poder completar el proceso.
```
terraform apply out.plan
```
El comando terraform apply muestra los resultados de la creación de los recursos definidos en sus archivos de configuración:
En Azure Portal, seleccione Todos los recursos en el menú de la izquierda para ver los recursos que se han creado para su nuevo clúster de Kubernetes.

10. Recuperación de un tiempo de espera de Cloud Shell

Si se agota el tiempo de espera de Cloud Shell, puede seguir estos pasos para recuperarla:

Inicie una sesión de Cloud Shell.
Cambie al directorio que contiene los archivos de configuración de Terraform.
```
cd /clouddrive/terraform-aks-k8s
```
Ejecute el siguiente comando:
```
export KUBECONFIG=./azurek8s
```

11. Prueba del clúster de Kubernetes

Las herramientas de Kubernetes se pueden usar para comprobar el clúster recién creado.

Obtenga la configuración de Kubernetes desde el estado de Terraform y almacénela en un archivo que kubectl puede leer.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Comprobar que el comando anterior no ha agregado un carácter ASCII de EOT
```
cat ./azurek8s
```
Si ve << EOT al principio y EOT al final, edite el contenido del archivo para quitarlos. Esto es necesario; de lo contrario, podría recibir el mensaje siguiente: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context
Establezca una variable de entorno para que kubectl seleccione la configuración correcta.
```
export KUBECONFIG=./azurek8s
```
Compruebe el mantenimiento del clúster.
```
kubectl get nodes
```
Debería ver los detalles de sus nodos de trabajo, y todos deberían tener el estado Listo, como se muestra en la siguiente imagen:

12. Supervisión del estado y los registros

Cuando se creó el clúster de AKS, se habilitó la supervisión para capturar métricas de mantenimiento para los nodos de clúster y los pods. Estas métricas de mantenimiento están disponibles en Azure Portal. Para obtener más información sobre la supervisión del estado de los contenedores, consulte Monitor Azure Kubernetes Service health (Supervisión del estado de Azure Kubernetes Service).

Solución de problemas de Terraform en Azure

Solución de problemas comunes al usar Terraform en Azure

Pasos siguientes

Más información sobre el uso de Terraform en Azure