Crea nodos de instancia única

Los nodos de instancia única son servidores físicos que cumplen con la función de alojar instancias de VM solo para tu proyecto específico. Aloja tus VM en nodos de instancia única para garantizar que tus instancias de VM no compartan hardware físico con instancias de VM de otros proyectos. Para obtener más información sobre cómo funcionan los nodos de instancia única, consulta la página de descripción general de nodos de instancia única.

Los nodos son parte de un grupo de nodos que tú creas. Un grupo de nodos puede contener múltiples instancias de varios tamaños, todas aisladas de otros proyectos. Puedes establecer afinidades de nodo para garantizar que las instancias de VM se ejecuten en grupos de nodos específicos.

Consulta los Precios de nodos de instancia única a fin de obtener información sobre cómo calcular precios y descuentos para nodos de instancia única.

Antes de comenzar

Restricciones

Revisa la sección Restricciones en la descripción general de los nodos de instancia única antes de crear y usar este tipo de nodos.

Crea y usa nodos de instancia única

En general, la creación de instancias en nodos de instancia única requiere el siguiente proceso:

  1. Crea una plantilla de nodo que especifique el tipo de nodo o CPU virtual y los requisitos de memoria. Además, especifica una región y etiquetas opcionales de afinidad de nodo. Cuando creas tus VM, puedes especificar que las VM solo se ejecuten en nodos que coincidan con las etiquetas de afinidad de nodo.
  2. Usa la plantilla para crear un grupo de nodos con uno o más nodos de instancia única. Puedes reducir el número de nodos a cero cuando ya no los necesites.
  3. Crea instancias en tus grupos de nodos:
    • Crea instancias de VM individuales en el grupo de nodos con cualquier tipo predefinido de máquina o tipo personalizado de máquina. El tipo de máquina debe tener dos o más CPU virtuales.
    • Crea grupos de instancias administrados en el grupo de nodos con una plantilla de instancias. Aunque un escalador automático puede controlar el tamaño de un grupo de instancias administrado en tus nodos, el escalador automático no puede controlar el tamaño del grupo de nodos.

Crea instancias y grupos de nodos

Crea una plantilla de nodo para definir sus propiedades de los nodos en un grupo. Una vez creada, úsala para crear uno o más grupos de nodos. Luego, crea instancias nuevas en esos grupos de nodos.

Console

Crea un nodo y sus instancias con Google Cloud Platform Console:

  1. Ve a la página de nodos de instancia única.

    Ir a la página Nodos de instancia única

  2. Haz clic en Crear plantilla de nodo para comenzar a crear una plantilla de nodo.
  3. Especifica la región donde planeas ejecutar tu grupo de nodos.
  4. Especifica el tipo de nodo que quieres que usen tus grupos de nodos. También puedes especificar el nodo más pequeño disponible, lo que permite que los grupos de nodos se ejecuten en cualquier tipo de nodo disponible.
  5. De forma opcional, agrega etiquetas de afinidad de nodo para definir qué instancias se programan de forma automática en tus grupos de nodos. Incluso si dejas en blanco las etiquetas de afinidad, más adelante podrás programar instancias en tus grupos de nodos por el nombre del grupo de nodos o por el nombre del nodo individual.
  6. Haz clic en Crear para terminar de crear tu plantilla de nodo.

Usa tu plantilla de nodo para crear un grupo de nodos.

  1. Ve a la página de nodos de instancia única.

    Ir a la página Nodos de instancia única

  2. Haz clic en Crear grupo de nodos para comenzar.
  3. Especifica la zona en la que quieres ejecutar tu grupo de nodos. Debes tener una plantilla de nodos en la misma región.
  4. Especifica la plantilla de nodo que quieres usar.
  5. Especifica la cantidad de nodos que quieres ejecutar en el grupo. Puedes cambiar esta cantidad más adelante.
  6. Haz clic en Crear para terminar de crear tu grupo de nodos.

Crea una instancia que se ejecute dentro de tu grupo de nodos o en nodos específicos. Si usaste etiquetas de afinidad de nodo específicas, puedes crear una instancia con el proceso normal y especificar la afinidad de nodo en la configuración de Instancia única. Para este ejemplo, crea las instancias directamente dentro de la página de detalles de tu grupo de nodos.

  1. Ve a la página de nodos de instancia única.

    Ir a la página Nodos de instancia única

  2. Haz clic en el nombre del grupo de nodos en el que quieres crear una instancia.
  3. Haz clic en Crear instancia para crear una instancia en cualquier lugar dentro de este grupo de nodos. Si quieres que tu instancia se ejecute en un nodo específico dentro del grupo, haz clic en el nombre de un nodo individual en este grupo para ver sus detalles. Luego, haz clic en Crear instancia para crear la instancia en ese nodo individual.
  4. Establece la configuración para tu instancia. Debido a que ya seleccionaste tu grupo de nodos o un nodo específico, la región, la zona y las etiquetas de afinidad de nodo predeterminadas ya están especificadas.
  5. Haz clic en Crear para terminar de crear tu instancia.

gcloud

Crea un nodo y sus instancias con la herramienta de línea de comandos de gcloud:

  1. Usa el comando compute sole-tenancy node-types list para identificar los tipos de nodos disponibles:

    gcloud compute sole-tenancy node-types list
    

    Compute Engine reemplazará de forma periódica los tipos de nodos más antiguos por otros más nuevos. Cuando se reemplaza un tipo de nodo, no podrás crear grupos de nodos con el tipo anterior y deberás actualizar tus plantillas de nodo para usar los tipos nuevos.

  2. Usa el comando compute sole-tenancy node-templates create para crear una plantilla de nodos nueva. Debido a que la lista de tipos de nodo disponibles cambiará con el tiempo, configura tus plantillas de nodo para usar requisitos de tipo de nodo flexibles. Por ejemplo, especifica --node-requirements vCPU=any,memory=any,localSSD=0, que permite que el nodo se ejecute en cualquier tipo de nodo disponible sin capacidad de SSD local.

    gcloud compute sole-tenancy node-templates create [TEMPLATE_NAME] \
        --region [REGION] --node-requirements vCPU=any,memory=any,localSSD=0
    

    en la que:

    • [TEMPLATE_NAME] es un nombre para la plantilla de nodo nueva.
    • [REGION] es la región donde usarás esta plantilla.

    También puedes seleccionar un tipo de nodo específico para usar en tu plantilla. Esta plantilla es menos flexible, pero garantiza que solo crees nodos si cumplen con los requisitos exactos de CPU virtual y memoria.

     gcloud compute sole-tenancy node-templates create [TEMPLATE_NAME] \
         --node-type [NODE_TYPE] --region [REGION]
    

    en la que:

    • [TEMPLATE_NAME] es un nombre para la plantilla de nodo nueva.
    • [NODE_TYPE] es el tipo de nodo que quieres usar para esta plantilla. Por ejemplo, puedes especificar el tipo de nodo n1-node-96-624 para crear un nodo con 96 CPU virtuales y 624 GB de memoria.
    • [REGION] es la región donde usarás esta plantilla.
  3. Después de crear la plantilla de nodo, crea un grupo de nodos. Usa el comando de compute sole-tenancy node-groups create:

    gcloud compute sole-tenancy node-groups create [GROUP_NAME] --zone [ZONE] \
        --node-template [TEMPLATE_NAME] --target-size [TARGET_SIZE]
    

    donde:

    • [GROUP_NAME] es un nombre para el grupo de nodos nuevo.
    • [ZONE] es la zona en la que se encuentra este grupo de nodos. Esta zona debe estar en la misma región que la plantilla de nodo que usas.
    • [TEMPLATE_NAME] es el nombre de la plantilla de nodo que quieres usar para crear este grupo.
    • [TARGET_SIZE] es el número de nodos que quieres crear en el grupo.
  4. Después de crear el grupo de nodos, puedes crear instancias dentro de los grupos de nodos con el comando compute instances create. Especifica una marca --node-group que indique el nombre de tu grupo de nodos. Por ejemplo, puedes crear una instancia con un tipo personalizado de máquina:

    gcloud compute instances create [INSTANCE_NAME] --zone [ZONE] \
        --image-family [IMAGE_FAMILY] --image-project [IMAGE_PROJECT] \
        --node-group [GROUP_NAME] --custom-cpu [VCPUS] --custom-memory [MEMORY]
    

    en la que:

    • [INSTANCE_NAME] es el nombre de la instancia nueva.
    • [ZONE] es la zona en la que se encuentra tu grupo de nodos.
    • [IMAGE_FAMILY] es una de las familias de imágenes disponibles.
    • [IMAGE_PROJECT] es el proyecto de imagen al que pertenece esa familia de imágenes.
    • [GROUP_NAME] es el nombre del grupo de nodos en el que quieres ubicar esta instancia.
    • [VCPUS] es la cantidad de CPU virtuales que quieres usar con esta instancia.
    • [MEMORY] es la cantidad de memoria para la instancia en incrementos de 256 MB. Por ejemplo, puedes especificar 5.25GB o 5376MB.

    De forma opcional, puedes crear grupos de instancias administrados dentro de tu grupo de nodos. Crea una plantilla de instancias con el comando instance-templates create y, luego, incluye una marca --node-group que indique el nombre del grupo de nodos:

    gcloud compute instance-templates create [INSTANCE_TEMPLATE] \
        --image-family [IMAGE_FAMILY] --image-project [IMAGE_PROJECT] \
        --node-group [GROUP_NAME] \
        --custom-cpu [VCPUS] --custom-memory [MEMORY]
    

    en la que:

    • [INSTANCE_TEMPLATE] es el nombre de la nueva plantilla de instancias.
    • [IMAGE_FAMILY] es una de las familias de imágenes disponibles.
    • [IMAGE_PROJECT] es el proyecto de imagen al que pertenece esa familia de imágenes.
    • [GROUP_NAME] es el nombre del grupo de nodos en el que quieres ubicar esta instancia.
    • [VCPUS] es la cantidad de CPU virtuales que quieres usar con esta instancia.
    • [MEMORY] es la cantidad de memoria para la instancia en incrementos de 256 MB. Por ejemplo, puedes especificar 5.25GB o 5376MB.

    Crea un grupo de instancias con el comando compute instance-groups managed create:

    gcloud compute instance-groups managed create [INSTANCE_GROUP_NAME] \
        --zone [ZONE] --size [SIZE] --template [INSTANCE_TEMPLATE]
    

    en el que reemplazarías los siguientes elementos:

    • [INSTANCE_GROUP_NAME] es el nombre de este grupo de instancias.
    • [SIZE] es el número de instancias de VM que quieres incluir en este grupo de instancias. Tu grupo de nodos debe tener suficientes recursos para admitir las instancias en este grupo de instancias administrado.
    • [INSTANCE_TEMPLATE] es el nombre de la plantilla de instancias que quieres usar para crear este grupo. La plantilla debe tener una afinidad de nodo que apunte al grupo de nodos deseado.
    • [ZONE] es la zona en la que se encuentra tu grupo de nodos.

API

Crea un nodo y sus instancias con los métodos en la API de Compute Engine:

  1. En la API, crea una solicitud GET para recuperar una lista de tipos de nodos disponibles con el método compute.nodetypes.list:

    GET https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/nodeTypes
    

    en la que:

    • [PROJECT_ID] es el ID del proyecto.
    • [ZONE] es la zona desde la que quieres recuperar los tipos de nodos disponibles.
  2. Crea una solicitud POST al método compute.nodetemplates.insert para crear una plantilla de nodos nueva. Para obtener la mayor flexibilidad, especifica una propiedad nodeTypeFlexibility con los valores cpus y memory establecidos en any, lo que permite que el nodo se ejecute en cualquier tipo de nodo disponible sin capacidad de SSD local.

    POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/nodeTemplates
    
    {
     "name": "[TEMPLATE_NAME]",
     "nodeTypeFlexibility": {
      "cpus": "any",
      "memory": "any"
     }
    }
    

    en la que:

    • [PROJECT_ID] es el ID del proyecto.
    • [REGION] es la zona desde la que quieres recuperar los tipos de nodos disponibles.
    • [TEMPLATE_NAME] es un nombre para la plantilla de nodo nueva.

    También puedes seleccionar un tipo de nodo específico para usar en tu plantilla. Esta plantilla es menos flexible, pero garantiza que solo crees nodos si cumplen con los requisitos exactos de CPU virtual y memoria.

    POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/[REGION]/nodeTemplates
    
    {
     "name": "[TEMPLATE_NAME]",
     "nodeType": "[NODE_TYPE]"
    }
    

    en la que:

    • [PROJECT_ID] es el ID del proyecto.
    • [TEMPLATE_NAME] es un nombre para la plantilla de nodo nueva.
    • [NODE_TYPE] es el tipo de nodo que quieres usar para esta plantilla. Por ejemplo, puedes especificar el tipo de nodo n1-node-96-624 para crear un nodo con 96 CPU virtuales y 624 GB de memoria.
    • [REGION] es la región donde usarás esta plantilla.
  3. Después de crear la plantilla de nodo, crea un grupo de nodos. Usa el método compute.nodeGroups.insert:

    POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/nodeGroups?initialNodeCount=[TARGET_SIZE]
    
    {
     "nodeTemplate": "regions/[REGION]/nodeTemplates/[TEMPLATE_NAME]",
     "name": "[GROUP_NAME]"
    }
    

    en el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [ZONE] es la zona en la que se encuentra este grupo de nodos. Esta zona debe estar en la misma región que la plantilla de nodo que usas.
    • [TARGET_SIZE] es el número de nodos que quieres crear en el grupo.
    • [REGION] es la región donde se encuentra la plantilla de nodo.
    • [TEMPLATE_NAME] es un nombre para la plantilla de nodo nueva.
    • [GROUP_NAME] es un nombre para el grupo de nodos nuevo.
    • [TEMPLATE_NAME] es el nombre de la plantilla de nodo que quieres usar para crear este grupo.
  4. Después de crear el grupo de nodos, puedes crear instancias dentro de los grupos de nodos con el método compute.instances.insert. Especifica una entrada nodeAffinities que indique el nombre del grupo de nodos. Por ejemplo, puedes crear una instancia con un tipo personalizado de máquina:

    POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instances
    
    {
     "machineType": "zones/[ZONE]/machineTypes/custom-[VCPUS]-[MEMORY]",
     "name": "[INSTANCE_NAME]",
     "scheduling": {
      "nodeAffinities": [
       {
        "key": "compute.googleapis.com/node-group-name",
        "operator": "IN",
        "values": [
         "[GROUP_NAME]"
        ]
       }
      ]
     },
     "networkInterfaces": [
      {
       "network": "global/networks/[NETWORK]",
       "subnetwork": "regions/[REGION]/subnetworks/[SUBNETWORK]"
      }
     ],
     "disks": [
      {
       "boot": true,
       "initializeParams": {
        "sourceImage": "projects/[IMAGE_PROJECT]/global/images/family/[IMAGE_FAMILY]"
       }
      }
     ]
    }
    

    en la que:

    • [PROJECT_ID] es el ID del proyecto.
    • [INSTANCE_NAME] es el nombre de la instancia nueva.
    • [ZONE] es la zona en la que se encuentra tu grupo de nodos.
    • [REGION] es la región donde se encuentran la plantilla de nodo y tu subred.
    • [IMAGE_FAMILY] es una de las familias de imágenes disponibles.
    • [IMAGE_PROJECT] es el proyecto de imagen al que pertenece esa familia de imágenes.
    • [GROUP_NAME] es el nombre del grupo de nodos en el que quieres ubicar esta instancia.
    • [VCPUS] es la cantidad de CPU virtuales que quieres usar con esta instancia.
    • [MEMORY] es la cantidad de memoria para la instancia en MB. Por ejemplo, puedes especificar 5376MB.
    • [NETWORK] es el nombre de la red a la que quieres conectar tu instancia.
    • [SUBNETWORK] es el nombre de la subred a la que quieres conectar tu instancia.

    De forma opcional, puedes crear grupos de instancias administrados dentro de tu grupo de nodos. Crea una plantilla de instancias mediante el método compute.instanceTemplates.insert y especifica una entrada nodeAffinities que indique el nombre del grupo de nodos:

    POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instance-templates
    
    {
    "name": "[TEMPLATE_NAME]",
    "properties": {
       "machineType": "custom-[VCPUS]-[MEMORY]",
       "name": "[INSTANCE_NAME]",
       "scheduling": {
        "nodeAffinities": [
         {
          "key": "compute.googleapis.com/node-group-name",
          "operator": "IN",
          "values": [
           "[GROUP_NAME]"
          ]
         }
        ]
       },
       "networkInterfaces": [
        {
         "network": "global/networks/[NETWORK]",
         "subnetwork": "regions/[REGION]/subnetworks/[SUBNETWORK]"
        }
       ],
       "disks": [
        {
         "boot": true,
         "initializeParams": {
          "sourceImage": "projects/[IMAGE_PROJECT]/global/images/family/[IMAGE_FAMILY]"
         }
        }
       ]
      }
    }
    

    en la que:

    • [PROJECT_ID] es el ID del proyecto.
    • [INSTANCE_NAME] es el nombre de la instancia nueva.
    • [ZONE] es la zona en la que se encuentra tu grupo de nodos.
    • [REGION] es la región donde se encuentran la plantilla de nodo y tu subred.
    • [TEMPLATE_NAME] es el nombre de la nueva plantilla de instancias.
    • [IMAGE_FAMILY] es una de las familias de imágenes disponibles.
    • [IMAGE_PROJECT] es el proyecto de imagen al que pertenece esa familia de imágenes.
    • [GROUP_NAME] es el nombre del grupo de nodos en el que quieres ubicar esta instancia.
    • [VCPUS] es la cantidad de CPU virtuales que quieres usar con esta instancia.
    • [MEMORY] es la cantidad de memoria para la instancia en MB. Por ejemplo, puedes especificar 5376MB.
    • [NETWORK] es el nombre de la red a la que quieres conectar tu instancia.
    • [SUBNETWORK] es el nombre de la subred a la que quieres conectar tu instancia.

    Crea un grupo de instancias con el método compute.instanceGroupManagers.insert:

    POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instanceGroupManagers
    
    {
     "baseInstanceName": "default",
     "name": "[INSTANCE_GROUP_NAME]",
     "targetSize": [SIZE],
     "instanceTemplate": "global/instanceTemplates/[INSTANCE_TEMPLATE]"
    }
    

    en el que:

    • [PROJECT_ID] es el ID del proyecto.
    • [ZONE] es la zona en la que se encuentra tu grupo de nodos.
    • [INSTANCE_GROUP_NAME] es el nombre de este grupo de instancias.
    • [BASE_INSTANCE_NAME] es el nombre del prefijo para cada una de las instancias en tu grupo de instancias administrado.
    • [SIZE] es el número de instancias de VM que quieres incluir en este grupo de instancias. Tu grupo de nodos debe tener suficientes recursos para admitir las instancias en este grupo de instancias administrado.
    • [INSTANCE_TEMPLATE] es el nombre de la plantilla de instancias que quieres usar para crear este grupo. La plantilla debe tener una afinidad de nodo que apunte al grupo de nodos deseado.

Opciones de nodo de instancia única

A continuación, se incluyen opciones adicionales que puedes especificar para tus plantillas de nodo.

Opción de reinicio de servidores mínimos

Si se establece esta opción, se especifica que, si se produce un evento de mantenimiento, las VM en este grupo de nodos se reiniciarán en el mismo servidor físico, si es posible. Si el mismo servidor físico no está disponible, se creará uno nuevo y se agregará al grupo de nodos.

Esto es diferente a las etiquetas de afinidad de nodos, que solo garantizan que ciertas VM se creen en nodos que tengan etiquetas específicas; no afecta el hecho de que el servidor físico subyacente permanece igual durante toda la vida del grupo de nodos.

Para especificar esta opción, haz lo siguiente:

Console

En la página sobre cómo crear una plantilla de nodos, expande Configuración avanzada de reinicio de nodo y selecciona Servidores mínimos.

gcloud

Con la herramienta gcloud, especifica la marca --server-binding restart-node-on-minimal-servers cuando crees una plantilla de nodo.

API

Cuando realices una solicitud HTTP directa, proporciona el objeto serverBinding con la string type: restart-node-on-minimal-servers como parte de la solicitud al momento de crear una plantilla de nodo.

{
  "serverBinding":
    {
      "type": "RESTART_NODE_ON_MINIMAL_SERVERS"
    }
}

Configura la afinidad de nodo

Puedes establecer afinidades o antiafinidades de nodo para determinar qué nodos usan tus instancias y grupos de instancias administrados como sistemas de host. Cuando estableces afinidades de nodo, debes elegir de forma explícita qué nodos de instancia única alojan a qué VM.

De forma predeterminada, a cada nodo se le asignan las siguientes etiquetas de afinidad:

  • Cada nodo en un grupo tiene una etiqueta de afinidad que coincide con el nombre del grupo de nodos:
    • Clave: compute.googleapis.com/node-group-name
    • Valor: el nombre del grupo de nodos.
  • Cada nodo tiene una etiqueta de afinidad que coincide con el nombre del nodo. Los nombres del nodo se generan de forma automática:
    • Clave: compute.googleapis.com/node-name
    • Valor: el nombre del nodo individual.

Puedes configurar etiquetas adicionales de afinidad o antiafinidad para que tus instancias se ejecuten solo en los grupos de nodos que quieras o compartan nodos solo con instancias de la misma afinidad. Esto te permite mantener datos sensibles juntos en grupos de nodos específicos, separados de tus otros grupos de nodos y otras instancias de VM que se ejecutan en Compute Engine.

Por ejemplo, puede que quieras crear un grupo de nodos para el desarrollo y otro separado destinado a las cargas de trabajo de producción. Puedes usar el siguiente proceso:

  1. Crea dos plantillas de nodos con dos etiquetas diferentes, workload=frontend,environment=prod y workload=frontend,environment=dev. La etiqueta workload indica que estos grupos de nodos están destinados a cargas de trabajo de frontend, mientras que la etiqueta environment distingue entre entornos prod y dev:

    gcloud compute sole-tenancy node-templates create production-template \
       --node-requirements vCPU=any,memory=any,localSSD=0 --node-affinity-labels workload=frontend,environment=prod
    
    gcloud compute sole-tenancy node-templates create development-template \
       --node-requirements vCPU=any,memory=any,localSSD=0 --node-affinity-labels workload=frontend,environment=dev
    
  2. Crea varios grupos de nodos con las plantillas de producción y desarrollo. Por ejemplo, puedes tener un grupo de nodos de producción grande y varios grupos de nodos de desarrollo más pequeños. De forma opcional, puedes crear estos grupos en zonas distintas y con diferentes tamaños de destino para adaptarse al escalamiento de las cargas de trabajo:

    gcloud compute sole-tenancy node-groups create production-group \
        --node-template production-template --target-size 5 --zones us-west1-b
    
    gcloud compute sole-tenancy node-groups create development-group-east1 \
        --node-template development-template --target-size 1 --zones us-east1-d
    
    gcloud compute sole-tenancy node-groups create development-group-east2 \
        --node-template development-template --target-size 1 --zones us-east1-d
    
  3. Para tus instancias de producción, crea un archivo node-affinity-prod.json a fin de articular con mayor claridad cómo quieres que se ejecute la afinidad en tus instancias de producción. Por ejemplo, puede crear un archivo que indique a las instancias que se ejecuten solo en nodos con las afinidades workload=frontend y environment=prod:

    [{
    "key" : "workload",
    "operator" : "IN",
    "values" : ["frontend"]
    },
    {
    "key" : "environment",
    "operator" : "IN",
    "values" : ["prod"]
    }
    ]
    
  4. Usa el archivo node-affinity-prod.json a fin de crear una plantilla de instancias con las propiedades que desees para tus instancias de VM de producción:

    gcloud compute instance-templates create production-template \
        --image-family production-images --image-project my-project \
        --node-affinity-file node-affinity-prod.json \
        --custom-cpu 3 --custom-memory 4096
    
  5. Inicia un grupo de instancias con la plantilla de producción que se ejecuta en tu nodo de producción:

    gcloud compute instance-groups managed create production-group \
        --zone us-west1-b --size 4 --template production-template
    

    Las instancias en el grupo se inician y se ejecutan solo en los grupos de nodos que tienen las afinidades workload=frontend y environment=prod.

Configura etiquetas antiafinidad

En el ejemplo anterior, se describe cómo usar etiquetas de afinidad. También puedes aprovechar las etiquetas antiafinidad para asegurarte de que tus VM eviten nodos con ciertas etiquetas. Supongamos que, además de las instancias de VM de producción que creaste con anterioridad, también quieres crear algunas instancias de VM para fines de desarrollo, pero no tienes que alojarlas en los mismos nodos que alojan tus instancias de producción.

  1. Para las instancias de desarrollo, crea un archivo node-affinity-dev.json a fin de articular con mayor claridad cómo quieres que funcione la afinidad en tus instancias de desarrollo. Por ejemplo, puedes crear un archivo que configure las instancias para que se ejecuten en cualquier nodo con la afinidad workload=frontend, siempre que no sea environment=prod:

    [{
    "key" : "workload",
    "operator" : "IN",
    "values" : ["frontend"]
    },
    {
    "key" : "environment",
    "operator" : "NOT",
    "values" : ["prod"]
    }
    ]
    
  2. Para el desarrollo, puedes crear una instancia individual que realice pruebas, en lugar de un grupo de instancias completo. Usa el archivo node-affinity-dev.json para crear la instancia. Por ejemplo, si deseas probar una imagen de desarrollo específica llamada development-image-1, deberías crear la instancia y configurar sus afinidades con el siguiente comando:

    gcloud compute instances create dev-1 \
        --image development-image-1 --image-project my-project \
        --node-affinity-file node-affinity-dev.json \
        --custom-cpu 3 --custom-memory 4096 --zone us-east1-d
    

    Esta instancia se inicia y se ejecuta solo en los grupos de nodos que tienen workload=frontend. Sin embargo, no se ejecutarán en ningún grupo de nodos configurado con la afinidad environment=prod.

Para crear tus propias opciones de configuración de afinidad, crea una plantilla de nodo y ejecuta nodos con tus propias claves y valores de afinidad. Luego, configura instancias con tus propios archivos affinity.json que determinan en qué nodos se pueden ejecutar las instancias.

Próximos pasos

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Documentación de Compute Engine