Esta página se ha traducido con Cloud Translation API.

Migrar de Docker a imágenes de nodo de containerd

Estándar

En esta página se explica cómo migrar tu clúster Standard y tus grupos de nodos de Google Kubernetes Engine (GKE) de Docker a imágenes de nodo que usen el tiempo de ejecución de contenedores containerd.

Información general

Los nodos de Kubernetes usan el entorno de ejecución de contenedores para iniciar, gestionar y detener los contenedores que se ejecutan en los pods. El runtime de containerd es un runtime de contenedores estándar del sector compatible con GKE.

El tiempo de ejecución de containerd proporciona la abstracción de capas que permite implementar un amplio conjunto de funciones, como gVisor y transmisión de imágenes, para ampliar la funcionalidad de GKE. El entorno de ejecución de containerd se considera más eficiente en cuanto a recursos y más seguro que el entorno de ejecución de Docker.

Para migrar el entorno de ejecución del contenedor, sigue estos pasos:

Identificar los nodos que usan el tiempo de ejecución de Docker
Verificar el impacto de la migración
Cambiar la imagen del nodo

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.
Nota: Si ya tienes instalada la CLI de gcloud, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

Identificar los nodos que usan el tiempo de ejecución de Docker

Puedes comprobar qué nodos usan imágenes de nodo basadas en Docker con los siguientes métodos:

Usa una secuencia de comandos para iterar en todos los nodos de todos los clústeres de GKE de tu Google Cloud proyecto.
Usa Google Cloud CLI, kubectl o la consola Google Cloud para identificar las imágenes de los nodos.
Usa estadísticas y recomendaciones de obsolescencia para identificar clústeres y nodos en zonas o regiones específicas de unGoogle Cloud proyecto.

Te recomendamos que uses una secuencia de comandos para identificar rápidamente todos los nodos que necesitas migrar.

Usar una secuencia de comandos para identificar nodos de Docker

El siguiente script itera por cada nodo de cada clúster de los proyectos disponibles y te ofrece recomendaciones prácticas, como las siguientes:

Si el aprovisionamiento automático de nodos está configurado para imágenes de Docker
Equivalentes de imagen de nodo de containerd sugeridos para la migración
Versiones de imagen de nodo sugeridas para la migración
Comandos sugeridos para migrar los nodos y ajustes identificados

La secuencia de comandos ignora los clústeres de Autopilot de GKE, que usan la imagen de nodo de Container-Optimized OS con containerd de forma predeterminada.

Ejecuta la siguiente secuencia de comandos:

for project in $(gcloud projects list --format="value(projectId)")
do
  echo "ProjectId: $project"
  for clusters in $( \
    gcloud container clusters list \
      --project $project \
      --format="csv[no-heading](name,location,autopilot.enabled,currentMasterVersion,autoscaling.enableNodeAutoprovisioning,autoscaling.autoprovisioningNodePoolDefaults.imageType)")
  do
    IFS=',' read -r -a clustersArray <<< "$clusters"
    cluster_name="${clustersArray[0]}"
    cluster_zone="${clustersArray[1]}"
    cluster_isAutopilot="${clustersArray[2]}"
    cluster_version="${clustersArray[3]}"
    cluster_minorVersion=${cluster_version:0:4}
    cluster_autoprovisioning="${clustersArray[4]}"
    cluster_autoprovisioningImageType="${clustersArray[5]}"

    if [ "$cluster_isAutopilot" = "True" ]; then
      echo "  Cluster: $cluster_name (autopilot) (zone: $cluster_zone)"
      echo "    Autopilot clusters are running Containerd."
    else
      echo "  Cluster: $cluster_name (zone: $cluster_zone)"

      if [ "$cluster_autoprovisioning" = "True" ]; then
        if [ "$cluster_minorVersion"  \< "1.20" ]; then
          echo "    Node autoprovisioning is enabled, and new node pools will have image type 'COS'."
          echo "    This settings is not configurable on the current version of a cluster."
          echo "    Please upgrade you cluster and configure the default node autoprovisioning image type."
          echo "    "
        else
          if [ "$cluster_autoprovisioningImageType" = "COS" ]; then
            echo "    Node autoprovisioning is configured to create new node pools of type 'COS'."
            echo "    Run the following command to update:"
            echo "    gcloud container clusters update '$cluster_name' --project '$project' --zone '$cluster_zone' --enable-autoprovisioning --autoprovisioning-image-type='COS_CONTAINERD'"
            echo "    "
          fi

          if [ "$cluster_autoprovisioningImageType" = "UBUNTU" ]; then
            echo "    Node autoprovisioning is configured to create new node pools of type 'UBUNTU'."
            echo "    Run the following command to update:"
            echo "    gcloud container clusters update '$cluster_name' --project '$project' --zone '$cluster_zone' --enable-autoprovisioning --autoprovisioning-image-type='UBUNTU_CONTAINERD'"
            echo "    "
          fi
        fi
      fi

      for nodepools in $( \
        gcloud container node-pools list \
          --project $project \
          --cluster $cluster_name \
          --zone $cluster_zone \
          --format="csv[no-heading](name,version,config.imageType)")
      do
        IFS=',' read -r -a nodepoolsArray <<< "$nodepools"
        nodepool_name="${nodepoolsArray[0]}"
        nodepool_version="${nodepoolsArray[1]}"
        nodepool_imageType="${nodepoolsArray[2]}"

        nodepool_minorVersion=${nodepool_version:0:4}

        echo "    Nodepool: $nodepool_name, version: $nodepool_version ($nodepool_minorVersion), image: $nodepool_imageType"

        minorVersionWithRev="${nodepool_version/-gke./.}"
        linuxGkeMinVersion="1.14"
        windowsGkeMinVersion="1.21.1.2200"

        suggestedImageType="COS_CONTAINERD"

        if [ "$nodepool_imageType" = "UBUNTU" ]; then
          suggestedImageType="UBUNTU_CONTAINERD"
        elif [ "$nodepool_imageType" = "WINDOWS_LTSC" ]; then
          suggestedImageType="WINDOWS_LTSC_CONTAINERD"
        elif [ "$nodepool_imageType" = "WINDOWS_SAC" ]; then
          suggestedImageType="WINDOWS_SAC_CONTAINERD"
        fi

        tab=$'\n      ';
        nodepool_message="$tab Please update the nodepool to use Containerd."
        nodepool_message+="$tab Make sure to consult with the list of known issues https://cloud.google.com/kubernetes-engine/docs/concepts/using-containerd#known_issues."
        nodepool_message+="$tab Run the following command to upgrade:"
        nodepool_message+="$tab "
        nodepool_message+="$tab gcloud container clusters upgrade '$cluster_name' --project '$project' --zone '$cluster_zone' --image-type '$suggestedImageType' --node-pool '$nodepool_name'"
        nodepool_message+="$tab "

        # see https://cloud.google.com/kubernetes-engine/docs/concepts/node-images
        if [ "$nodepool_imageType" = "COS_CONTAINERD" ] || [ "$nodepool_imageType" = "UBUNTU_CONTAINERD" ] ||
           [ "$nodepool_imageType" = "WINDOWS_LTSC_CONTAINERD" ] || [ "$nodepool_imageType" = "WINDOWS_SAC_CONTAINERD" ]; then
          nodepool_message="$tab Nodepool is using Containerd already"
        elif ( [ "$nodepool_imageType" = "WINDOWS_LTSC" ] || [ "$nodepool_imageType" = "WINDOWS_SAC" ] ) &&
               [ "$(printf '%s\n' "$windowsGkeMinVersion" "$minorVersionWithRev" | sort -V | head -n1)" != "$windowsGkeMinVersion" ]; then
          nodepool_message="$tab Upgrade nodepool to the version that supports Containerd for Windows"
        elif [ "$(printf '%s\n' "$linuxGkeMinVersion" "$minorVersionWithRev" | sort -V | head -n1)" != "$linuxGkeMinVersion" ]; then
          nodepool_message="$tab Upgrade nodepool to the version that supports Containerd"
        fi
        echo "$nodepool_message"
      done
    fi # not autopilot
  done
done

# Sample output:
#
# ProjectId:  my-project-id
#  Cluster: autopilot-cluster-1 (autopilot) (zone: us-central1)
#    Autopilot clusters are running Containerd.
#  Cluster: cluster-1 (zone: us-central1-c)
#    Nodepool: default-pool, version: 1.18.12-gke.1210 (1.18), image: COS
#
#       Please update the nodepool to use Containerd.
#       Make sure to consult with the list of known issues https://cloud.google.com/kubernetes-engine/docs/concepts/using-containerd#known_issues.
#       Run the following command to upgrade:
#
#       gcloud container clusters upgrade 'cluster-1' --project 'my-project-id' --zone 'us-central1-c' --image-type 'COS_CONTAINERD' --node-pool 'default-pool'
#
#    Nodepool: pool-1, version: 1.18.12-gke.1210 (1.18), image: COS
#
#       Please update the nodepool to use Containerd.
#       Make sure to consult with the list of known issues https://cloud.google.com/kubernetes-engine/docs/concepts/using-containerd#known_issues.
#       Run the following command to upgrade:
#
#       gcloud container clusters upgrade 'cluster-1' --project 'my-project-id' --zone 'us-central1-c' --image-type 'COS_CONTAINERD' --node-pool 'pool-1'
#
#    Nodepool: winpool, version: 1.18.12-gke.1210 (1.18), image: WINDOWS_SAC
#
#       Upgrade nodepool to the version that supports Containerd for Windows
#
#  Cluster: another-test-cluster (zone: us-central1-c)
#    Nodepool: default-pool, version: 1.20.4-gke.400 (1.20), image: COS_CONTAINERD
#
#      Nodepool is using Containerd already
#

Identificar imágenes de nodos con Google Cloud

Puedes consultar las imágenes de los nodos que ya tengas con la CLI de Google Cloud,kubectl o con la Google Cloud consola.

gcloud

Ejecuta el siguiente comando:

gcloud container node-pools list \
    --cluster=CLUSTER_NAME \
    --format="table(name,version,config.imageType)"

Sustituye CLUSTER_NAME por el nombre de tu clúster.

El resultado debería ser similar al siguiente:

NAME          NODE_VERSION    IMAGE_TYPE
default-pool  1.19.6-gke.600  UBUNTU

Consola

Ve a la página Google Kubernetes Engine en la Google Cloud consola.

Ir a Google Kubernetes Engine
En la lista de clústeres, haz clic en el nombre del clúster que quieras verificar.
Selecciona la pestaña Nodos.
En la sección Grupos de nodos, comprueba el valor de la columna Tipo de imagen.

kubectl

Ejecuta el siguiente comando:

kubectl get nodes -o wide

El resultado debería ser similar al siguiente:

# For Docker runtime
NAME         STATUS   VERSION             OS-IMAGE                             CONTAINER-RUNTIME
gke-node-1   Ready    v1.16.15-gke.6000   Container-Optimized OS from Google   docker://19.3.1
gke-node-2   Ready    v1.16.15-gke.6000   Container-Optimized OS from Google   docker://19.3.1
gke-node-3   Ready    v1.16.15-gke.6000   Container-Optimized OS from Google   docker://19.3.1

El valor de la columna CONTAINER-RUNTIME muestra el tiempo de ejecución y la versión.

Identificar clústeres mediante estadísticas y recomendaciones de obsolescencia

GKE detecta el uso de algunas funciones y APIs obsoletas, incluidas las imágenes de nodos basadas en Docker. Para obtener más información, consulta Desactivaciones de funciones y APIs.

Como parte de la detección del uso de funciones obsoletas, GKE genera estadísticas y recomendaciones que identifican el uso de imágenes de nodos basadas en Docker con el subtipo de estadística DEPRECATION_K8S_1_24_DOCKERSHIM.

Una combinación de información valiosa y recomendación identifica un clúster que tiene nodos que usan imágenes de nodos basadas en Docker. Cada estadística y recomendación proporciona una lista de los grupos de nodos específicos de un clúster que utilizan imágenes de nodo basadas en Docker y que deben migrarse a imágenes de nodo de containerd.

Para empezar, sigue las instrucciones para ver las estadísticas y las recomendaciones sobre la obsolescencia. En los comandos de la CLI de gcloud, usa la siguiente marca para ver solo las estadísticas de esta obsolescencia:

--filter="insightSubtype:DEPRECATION_K8S_1_24_DOCKERSHIM"

Una vez que hayas identificado los grupos de nodos del clúster que usan imágenes de nodo basadas en Docker, sigue las instrucciones para cambiar la imagen de nodo por una imagen de nodo de containerd.

Verificar el impacto de la migración

Antes de migrar tus clústeres y grupos de nodos de producción a imágenes de nodos que usen containerd, te recomendamos que pruebes el impacto de la migración en un entorno de staging para minimizar el riesgo de que se produzcan problemas.

Te recomendamos que, cuando migres los nodos, lo hagas de forma independiente a la actualización de los nodos para que puedas aislar las variables al verificar que las cargas de trabajo funcionan con la nueva configuración. Además, si actualizas el grupo de nodos a la versión 1.24 al mismo tiempo, no podrás deshacer el cambio, ya que la versión 1.24 no admite nodos Docker y no puedes cambiar a versiones secundarias anteriores.

Cambiar la imagen de nodo a una imagen de containerd

Si has usado la secuencia de comandos para identificar tus nodos de Docker, puedes usar los comandos sugeridos que devuelve la secuencia de comandos para cambiar los ajustes de aprovisionamiento automático de los nodos y las imágenes de los nodos por los equivalentes de containerd.

También puedes migrar nodos de un tipo de imagen de Docker a un tipo de imagen de containerd actualizando el grupo de nodos y configurando una imagen diferente mediante la interfaz de línea de comandos de gcloud o la Google Cloud consola.

GKE usa la estrategia de actualización de nodos y la configuración seleccionadas para migrar la imagen de un nodo. Para esta migración, te recomendamos que utilices la estrategia de actualización azul-verde, ya que, si tus cargas de trabajo tienen problemas con la nueva imagen de nodo durante la actualización, puedes restaurar el entorno anterior con la configuración original de la imagen de nodo.

gcloud

Ejecuta el siguiente comando:

gcloud container clusters upgrade CLUSTER_NAME \
    --image-type=NODE_IMAGE \
    --node-pool=POOL_NAME \
    --cluster-version=NODE_VERSION

Haz los cambios siguientes:

NODE_IMAGE: la imagen del nodo que quieres que usen los nodos.
POOL_NAME: el nombre del grupo de nodos que se va a migrar.
NODE_VERSION: la versión actual del nodo pool. Te recomendamos que definas esta marca, ya que, de lo contrario, GKE intentará actualizar la versión del grupo de nodos a la versión del plano de control y actualizar la imagen del nodo en la misma operación. Si el plano de control ejecuta la versión 1.24, el comando falla. Si el plano de control ejecuta la versión 1.23, el comando se ejecuta correctamente, lo que le impide probar los dos cambios (actualización de la versión y actualización de la imagen) de forma aislada.

El resultado debería ser similar al siguiente:

NAME          NODE_VERSION    IMAGE_TYPE
default-pool  1.23.6-gke.600  UBUNTU_CONTAINERD

Consola

Ve a la página Google Kubernetes Engine en la Google Cloud consola.

Ve a Google Kubernetes Engine
En la lista de clústeres, haz clic en el nombre del clúster que quieras verificar.
Haz clic en la pestaña Nodos.
En la sección Grupos de nodos, haz clic en el nombre del grupo de nodos que quieras modificar.
En la página Detalles del grupo de nodos, haga clic en Editar.
En la sección Nodos, en Tipo de imagen, haz clic en Cambiar.
Selecciona uno de los tipos de imagen de containerd.
Haz clic en Cambiar.

Volver a las imágenes de nodo de Docker

Si tus nodos se han migrado automáticamente o manualmente a nodos de containerd y has detectado un problema con tus cargas de trabajo, sigue estos pasos para volver a las imágenes de nodo de Docker:

Elige el paso siguiente en función del estado de la operación:
- Si la operación sigue en curso, puedes cancelarla y deshacerla.
- Si la operación se ha completado, sigue los pasos de la sección anterior y selecciona la imagen de Docker equivalente.
Configura una exclusión de mantenimiento para evitar temporalmente que GKE vuelva a intentar la migración.
Investiga la causa principal del problema para poder migrar de Docker y asegurarte de que tu clúster ejecuta una versión compatible de GKE.
Vuelve a intentar cambiar la imagen de nodo a una imagen de containerd. Si eliminas la exclusión de mantenimiento, GKE volverá a activar la operación.

Actualizar las configuraciones de las herramientas de infraestructura como código (IaC)

Si usas herramientas de IaC, como Terraform, Ansible o Pulumi, para gestionar clústeres de GKE, asegúrate de actualizar tus configuraciones para usar imágenes de nodo de containerd. De esta forma, evitarás que las herramientas concilien el estado deseado anterior con el nuevo estado real. Por ejemplo, el proveedor de Terraform de GKE admite tipos de imágenes configurables.

Actualiza las configuraciones para que la herramienta no vuelva a actualizar la imagen de nodo a una imagen de nodo basada en Docker después de haber migrado a imágenes de nodo de containerd.

Cambiar la imagen de nodo predeterminada para el aprovisionamiento automático de nodos

Si usas el aprovisionamiento automático de nodos en tu clúster, cambia el tipo de imagen predeterminado a una imagen de nodo de containerd. El cambio del tipo de imagen predeterminado solo se aplica a los nuevos grupos de nodos aprovisionados automáticamente. Debes cambiar manualmente la imagen de nodo de los grupos de nodos aprovisionados automáticamente.

Puedes cambiar el tipo de imagen de aprovisionamiento automático de nodos predeterminado mediante la CLI de gcloud o un archivo de configuración.

gcloud

Ejecuta el siguiente comando:

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-image-type=IMAGE_TYPE

Haz los cambios siguientes:

CLUSTER_NAME: el nombre del clúster que se va a actualizar.
IMAGE_TYPE: el tipo de imagen del nodo, que puede ser uno de los siguientes:
- cos_containerd
- ubuntu_containerd
  
  Nota: En ubuntu_containerd, especifica --autoprovisioning-scopes=https://www.googleapis.com/auth/devstorage.read_only en el comando.

Archivo

Puedes usar un archivo de configuración YAML para cambiar el tipo de imagen de nodo predeterminado del aprovisionamiento automático de nodos. Cuando usas un archivo, también debes especificar los valores máximos de los recursos de CPU y memoria.

Guarda el siguiente archivo YAML:

resourceLimits:
  - resourceType: 'cpu'
      minimum: 4
      maximum: 10
  - resourceType: 'memory'
      maximum: 64
autoprovisioningNodePoolDefaults:
  imageType: 'IMAGE_TYPE'

Sustituye IMAGE_TYPE por el tipo de imagen de containerd.

Aplica la configuración:

gcloud container clusters update CLUSTER_NAME \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=FILE_NAME

Sustituye FILE_NAME por la ruta del archivo de configuración.

Solución de problemas

Para solucionar problemas y consultar los problemas conocidos con soluciones alternativas, consulta el artículo Solucionar problemas del tiempo de ejecución del contenedor.

Migrar de Docker a imágenes de nodo de containerd Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Información general

Antes de empezar

Identificar los nodos que usan el tiempo de ejecución de Docker

Usar una secuencia de comandos para identificar nodos de Docker

Identificar imágenes de nodos con Google Cloud

gcloud

Consola

kubectl

Identificar clústeres mediante estadísticas y recomendaciones de obsolescencia

Verificar el impacto de la migración

Cambiar la imagen de nodo a una imagen de containerd

gcloud

Consola

Volver a las imágenes de nodo de Docker

Actualizar las configuraciones de las herramientas de infraestructura como código (IaC)

Cambiar la imagen de nodo predeterminada para el aprovisionamiento automático de nodos

gcloud

Archivo

Solución de problemas

Siguientes pasos

Migrar de Docker a imágenes de nodo de containerd