Inicio rápido: Implementación de un host de contenedor de Linux en Azure para un clúster de AKS mediante Terraform

Artículo
10/16/2024

Empiece a trabajar con el host de contenedor de Linux en Azure mediante Terraform para implementar un clúster de host de contenedor de Linux en Azure. Después de instalar los requisitos previos, implemente el código de Terraform, inicialice Terraform y cree y aplique un plan de ejecución de Terraform.

Terraform habilita la definición, vista previa e implementación de la infraestructura en la nube. Con Terraform, se crean archivos de configuración mediante la sintaxis de HCL. La sintaxis de HCL permite especificar el proveedor de la nube y los elementos que componen la infraestructura de la nube. Después de crear los archivos de configuración, se crea un plan de ejecución que permite obtener una vista previa de los cambios de infraestructura antes de implementarlos. Una vez que compruebe los cambios, aplique el plan de ejecución para implementar la infraestructura.

Nota

El código de ejemplo de este artículo se encuentra en el repositorio de GitHub de Terraform para Microsoft.

Requisitos previos

Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.
Si aún no ha configurado Terraform, puede hacerlo con una de las siguientes opciones:
Si aún no tiene una entidad de servicio de Azure, cree una. Anote los appId, display_name, password y tenant.
Necesita la herramienta de línea de comandos de Kubernetes kubectl. Si no la tiene, descargue kubectl.

Creación de un par de claves SSH

Para acceder a los nodos de AKS, se conectará mediante un par de claves SSH (pública y privada), que se genera mediante el comando ssh-keygen. De forma predeterminada, estos archivos se crean en el directorio ~/.ssh. La ejecución del comando ssh-keygen sobrescribe cualquier par de claves SSH con el mismo nombre que ya exista en la ubicación especificada.

Vaya a https://shell.azure.com para abrir Cloud Shell en el explorador.
Ejecute el comando ssh-keygen. En el ejemplo siguiente se crea un par de claves SSH con cifrado RSA y una longitud en bits de 4096:
```
ssh-keygen -t rsa -b 4096
```

Para más información sobre cómo crear claves SSH, consulte el artículo sobre Creación y administración de claves SSH para la autenticación en Azure.

Implementación del código de Terraform

Cree un directorio en el que probar el código de ejemplo de Terraform y conviértalo en el directorio actual.

Cree un archivo denominado providers.tf e inserte el siguiente código:

    terraform {
      required_version = ">=1.0"

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

    provider "azurerm" {
      features {}
    }

Cree un archivo denominado main.tf e inserte el siguiente código:

    # Generate random resource group name
    resource "random_pet" "rg_name" {
      prefix = var.resource_group_name_prefix
    }

    resource "azurerm_resource_group" "rg" {
      location = var.resource_group_location
      name     = random_pet.rg_name.id
    }

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

    resource "azurerm_log_analytics_workspace" "test" {
      location            = var.log_analytics_workspace_location
      # 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}"
      resource_group_name = azurerm_resource_group.rg.name
      sku                 = var.log_analytics_workspace_sku
    }

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

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

    resource "azurerm_kubernetes_cluster" "k8s" {
      location            = azurerm_resource_group.rg.location
      name                = var.cluster_name
      resource_group_name = azurerm_resource_group.rg.name
      dns_prefix          = var.dns_prefix
      tags                = {
        Environment = "Development"
      }

      default_node_pool {
        name       = "azurelinuxpool"
        vm_size    = "Standard_D2_v2"
        node_count = var.agent_count
        os_sku = "AzureLinux"
      }
      linux_profile {
        admin_username = "azurelinux"

        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
      }
    }

Del mismo modo, puede especificar Azure Linux os_sku en azurerm_kubernetes_cluster_node_pool.

Cree un archivo denominado variables.tf e inserte el siguiente código:

    variable "agent_count" {
        default = 3
    }

    # 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"
    }

    # Refer to https://azure.microsoft.com/global-infrastructure/services/?products=monitor for available Log Analytics regions.
    variable "log_analytics_workspace_location" {
      default = "eastus"
    }

    variable "log_analytics_workspace_name" {
      default = "testLogAnalyticsWorkspaceName"
    }

    # Refer to https://azure.microsoft.com/pricing/details/monitor/ for Log Analytics pricing
    variable "log_analytics_workspace_sku" {
      default = "PerGB2018"
    }

    variable "resource_group_location" {
      default     = "eastus"
      description = "Location of the resource group."
    }

    variable "resource_group_name_prefix" {
      default     = "rg"
      description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
    }

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

Cree un archivo denominado outputs.tf e inserte el siguiente código:

    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
    }

    output "resource_group_name" {
      value = azurerm_resource_group.rg.name
    }

Cree un archivo denominado terraform.tfvars e inserte el siguiente código:

    aks_service_principal_app_id = "<service_principal_app_id>"
    aks_service_principal_client_secret = "<service_principal_password>"

Inicialización de Terraform y creación de un plan de ejecución

Inicialice Terraform y descargue los módulos de Azure necesarios para administrar los recursos de Azure mediante el comando terraform init.
```
terraform init
```
Cree un plan de ejecución de Terraform mediante el comando terraform plan.
```
terraform plan -out main.tfplan
```
El comando terraform plan crea un plan de ejecución, pero no lo ejecuta. En su lugar, determina qué acciones son necesarias para crear la configuración especificada en los archivos de configuración. Este patrón le permite comprobar si el plan de ejecución coincide con sus expectativas antes de realizar cambios en los recursos reales.

El parámetro -out opcional permite especificar un archivo de salida para el plan. El uso del parámetro -out garantiza que el plan que ha revisado es exactamente lo que se aplica.

Para más información acerca de la seguridad y conservar los planes de ejecución, consulte las advertencias de seguridad.
Aplique el plan de ejecución de Terraform mediante el comando terraform apply.
```
terraform apply main.tfplan
```
El comando terraform apply anterior da por hecho que ejecutó anteriormente terraform plan -out main.tfplan. Si especificó un nombre de archivo diferente para el parámetro -out, use ese mismo nombre de archivo en la llamada a terraform apply. Si no ha utilizado el parámetro -out, llame a terraform apply sin ningún parámetro.

Verificación de los resultados

Obtenga el nombre del grupo de recursos mediante el siguiente comando echo.
```
echo "$(terraform output resource_group_name)"
```
Vaya a Azure Portal.
En Servicios de Azure, seleccione Grupos de recursos y busque el nuevo grupo de recursos para ver los siguientes recursos creados en esta demostración:
- Solución: de forma predeterminada, la demostración denomina esta solución ContainerInsights. El portal muestra el nombre del área de trabajo de la solución entre paréntesis.
- Servicio Kubernetes: de forma predeterminada, la demostración denomina este servicio k8stest. (Un clúster de Kubernetes administrado también se conoce como AKS/Azure Kubernetes Service).
- Área de trabajo de Log Analytics: de forma predeterminada, la demostración asigna a este área de trabajo un prefijo TestLogAnalyticsWorkspaceName- seguido de un número aleatorio.
Obtenga la configuración de Kubernetes del estado de Terraform y almacénela en un archivo que kubectl pueda leer usando el siguiente comando echo.
```
echo "$(terraform output kube_config)" > ./azurek8s
```
Verifique que el comando anterior no haya agregado un carácter ASCII EOT usando el siguiente comando cat.
```
cat ./azurek8s
```
Si viera << EOT al principio y EOT al final, quite estos caracteres del archivo. En caso contrario, es posible que reciba el siguiente mensaje de error: 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 mediante el siguiente comando export.
```
export KUBECONFIG=./azurek8s
```
Compruebe el estado del clúster mediante el comando kubectl get nodes.
```
kubectl get nodes
```
Cuando se creó el clúster de Host de contenedor de Linux en Azure, 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).

Se generaron varios valores de clave al aplicar el plan de ejecución de Terraform. Por ejemplo, se genera la dirección de host, el nombre de usuario del clúster del host de contenedor de Linux de Azure y la contraseña del clúster del host de contenedor de Linux de Azure.

Para ver todos los valores de salida, ejecute terraform output. Para ver un valor de salida específico, ejecute echo "$(terraform output <output_value_name>)".

Limpieza de recursos

Eliminación de recursos de AKS

Cuando ya no necesite los recursos creados con Terraform, puede quitarlos mediante los pasos siguientes.

Ejecute el comando terraform plan y especifique la marca destroy.
```
terraform plan -destroy -out main.destroy.tfplan
```
Quite el plan de ejecución mediante el comando terraform apply.
```
terraform apply main.destroy.tfplan
```

Eliminación de la entidad de servicio

Precaución

Elimine la entidad de servicio que usó en esta demostración solo si no la usa para nada más.

Obtenga el identificador de objeto de la entidad de servicio mediante el comando az ad sp list.

az ad sp list --display-name "<display_name>" --query "[].{\"Object ID\":id}" --output table

Elimine la entidad de servicio mediante el comando az ad sp delete.
```
az ad sp delete --id <service_principal_object_id>
```

Solución de problemas de Terraform en Azure

Solución de problemas comunes al usar Terraform en Azure.

Pasos siguientes

En este inicio rápido, ha implementado un clúster de host de contenedor de Linux en Azure. Para más información sobre el host de contenedor de Linux en Azure y recorrer un ejemplo completo de implementación y administración de clústeres, continúe con el tutorial sobre el host de contenedor de Linux en Azure.

Tutorial sobre el host de contenedor de Linux en Azure

Compartir a través de