Como criar nós de locatário individual

Os nós de locatário individual são servidores físicos dedicados a hospedar apenas instâncias de VM do projeto específico. Hospede as VMs em nós de locatário individual para garantir que as instâncias de VM não compartilhem hardware físico com instâncias de VM de outros projetos. Para saber mais sobre como os nós de locatário individual funcionam, consulte a página de visão geral de nós de locatário individual.

Os nós são parte de um grupo de nós que você cria. Um grupo de nós pode conter várias instâncias de diversos tamanhos, todas isoladas de outros projetos. É possível definir afinidades de nó para garantir que as instâncias de VM sejam executadas em grupos de nós específicos.

Consulte os preços de nós de locatário individual para saber como calcular preços e descontos para esse tipo de nó.

Antes de começar

Restrições

Revise a seção Restrições na visão geral de nós de locatário individual antes de criá-los e usá-los.

Como criar e usar nós de locatário único

Em geral, a criação de instâncias em nós de locatário individual requer o seguinte processo:

  1. Crie um modelo de nó que especifique o tipo de nó ou os requisitos de vCPU e memória. Além disso, especifique uma região e rótulos opcionais de afinidade de nó. Ao criar as VMs, é possível especificar que elas sejam executadas apenas em nós que correspondam aos rótulos de afinidade do nó.
  2. Use o modelo para criar um grupo com um ou mais nós de locatário individual. Reduza o número de nós a zero, quando não precisar mais deles.
  3. Crie instâncias nos grupos de nós:
    • Crie instâncias de VM individuais no grupo de nós usando qualquer tipo de máquina predefinido ou personalizado. O tipo de máquina precisa ter duas ou mais vCPUs.
    • Crie grupos de instâncias gerenciadas no grupo de nós usando um modelo de instância. Um autoescalador pode controlar o tamanho de um grupo de instâncias gerenciadas nos nós, mas não pode controlar o tamanho do grupo de nós.

Como criar grupos de nós e instâncias

Crie um modelo de nó para definir as propriedades dos nós em um grupo. Depois de criar o modelo, use-o para criar um ou mais grupos de nós. Depois, crie novas instâncias nesses grupos de nós.

Console

Crie um nó e as respectivas instâncias usando o Console do Google Cloud Platform:

  1. Acesse a página de nós de locatário individual.

    Acessar a página de nós de locatário individual

  2. Clique em Criar um modelo de nó para começar a criar um modelo de nó.
  3. Especifique a região onde você planeja executar um grupo de nós.
  4. Especifique o tipo de nó a ser usado pelos grupos de nós. Outra opção é especificar o menor nó disponível, permitindo que os grupos de nós sejam executados em qualquer tipo de nó disponível.
  5. Se preferir, adicione rótulos de afinidade de nó para definir quais instâncias se programam automaticamente nos seus grupos de nó. Se deixar os rótulos de afinidade em branco, ainda será possível programar instâncias nos grupos de nó pelo nome do grupo ou do nó individual depois.
  6. Clique em Criar para concluir a criação do modelo de nó.

Use o modelo de nó para criar um grupo de nós.

  1. Acesse a página de nós de locatário individual.

    Acessar a página de nós de locatário individual

  2. Clique em Criar grupo de nós para começar a criar um grupo de nós.
  3. Especifique a região em que você planeja executar um grupo de nó. É preciso ter um modelo de nó na mesma região.
  4. Especifique o modelo de nó que você quer utilizar.
  5. Especifique o número de nós que quer executar no grupo. É possível alterar esse número mais tarde.
  6. Clique em Criar para concluir a criação do grupo de nós.

Crie uma instância que seja executada no grupo de nós ou em nós específicos. Se você tiver usado rótulos específicos de afinidade de nó, poderá criar uma instância usando o processo normal e especificar a afinidade do nó nas configurações de Locatário individual. Para este exemplo, crie as instâncias diretamente na página de detalhes do grupo de nós.

  1. Acesse a página de nós de locatário individual.

    Acessar a página de nós de locatário individual

  2. Clique no nome do grupo de nós em que você quer criar uma instância.
  3. Clique em Criar instância para criar uma instância em qualquer parte do grupo de nós. Para executar sua instância em um nó específico do grupo, clique no nome de um nó individual nesse grupo para visualizar os detalhes dele. Depois, clique em Criar instância para criar a instância nesse nó individual.
  4. Defina as configurações para sua instância. Como você selecionou o grupo de nós ou um nó específico, os rótulos de afinidade de nó regional, de zona ou padrão já estão especificados para você.
  5. Clique em Criar para concluir a criação dessa instância.

gcloud

Crie um nó e as respectivas instâncias usando a ferramenta de linha de comando gcloud:

  1. Use o comando compute sole-tenancy node-types list para identificar quais tipos de nós estão disponíveis para você:

    gcloud compute sole-tenancy node-types list
    

    O Compute Engine substituirá periodicamente os tipos de nós mais antigos por mais novos. Quando um tipo de nó for substituído, não será possível criar grupos de nós usando o tipo antigo e você precisará fazer upgrade dos seus modelos de nós para usar os novos tipos.

  2. Use o comando compute sole-tenancy node-templates create para criar um novo modelo de nó. Como a lista dos tipos de nós disponíveis mudará com o passar do tempo, configure os modelos de nós para usar requisitos de tipo de nó flexível. Por exemplo, especifique --node-requirements vCPU=any,memory=any,localSSD=0. Isso permite que o nó seja executado em qualquer tipo de nó disponível sem capacidade de SSD local.

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

    em que:

    • [TEMPLATE_NAME] é um nome para o novo modelo de nó.
    • [REGION] é a região onde você usará esse modelo.

    Também é possível selecionar um tipo de nó específico a ser usado no modelo. Esse modelo é menos flexível, mas garante que você só crie nós caso eles atendam aos requisitos exatos de memória de vCPU e sistema.

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

    em que:

    • [TEMPLATE_NAME] é um nome para o novo modelo de nó.
    • [NODE_TYPE] é o tipo de nó que você quer usar no modelo. Por exemplo, é possível especificar o tipo de nó n1-node-96-624 para criar um nó com 96 vCPUs e 624 GB de memória.
    • [REGION] é a região onde você usará esse modelo.
  3. Depois de criar o modelo, crie um grupo de nós. Use o comando 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]
    

    em que:

    • [GROUP_NAME] é um nome para o novo grupo de nós.
    • [ZONE] é a zona em que esse grupo de nós está localizado. Essa zona precisa estar na mesma região que o modelo de nó que você está usando.
    • [TEMPLATE_NAME] é o nome do modelo de nó que você quer usar para criar esse grupo.
    • [TARGET_SIZE] é o número de nós que você quer criar no grupo.
  4. Depois de criar o grupo de nós, é possível criar instâncias nos grupos de nós usando o comando compute instances create. Especifique uma sinalização --node-group que aponte para o nome do grupo de nós. Por exemplo, é possível criar uma instância com um tipo de máquina personalizado:

    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]
    

    em que:

    • [INSTANCE_NAME] é o nome da nova instância.
    • [ZONE] é a zona em que o grupo de nós está localizado.
    • [IMAGE_FAMILY] é uma das famílias de imagens disponíveis.
    • [IMAGE_PROJECT] é o projeto de imagem a que essa família de imagens pertence.
    • [GROUP_NAME] é o nome do grupo de nós em que você quer localizar essa instância.
    • [VCPUS] é o número de vCPUs que você quer usar com essa instância.
    • [MEMORY] é a quantidade de memória para a instância em incrementos de 256 MB. Por exemplo, é possível especificar 5.25GB ou 5376MB

    Também é possível criar grupos de instâncias gerenciadas dentro do grupo de nós. Crie um modelo de instância usando o comando instance-templates create e inclua uma sinalização --node-group que aponte para o nome do grupo de nós:

    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]
    

    em que:

    • [INSTANCE_TEMPLATE] é o nome do novo modelo de instância.
    • [IMAGE_FAMILY] é uma das famílias de imagens disponíveis.
    • [IMAGE_PROJECT] é o projeto de imagem a que essa família de imagens pertence.
    • [GROUP_NAME] é o nome do grupo de nós em que você quer localizar essa instância.
    • [VCPUS] é o número de vCPUs que você quer usar com essa instância.
    • [MEMORY] é a quantidade de memória para a instância em incrementos de 256 MB. Por exemplo, é possível especificar 5.25GB ou 5376MB

    Crie um grupo de instâncias usando o comando compute instance-groups managed create:

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

    em que você substituiria:

    • [INSTANCE_GROUP_NAME] é o nome desse grupo de instâncias.
    • [SIZE] é o número de instâncias de VM que você quer incluir nesse grupo. O grupo de nós precisa ter recursos suficientes para acomodar as instâncias nesse grupo de instâncias gerenciadas.
    • [INSTANCE_TEMPLATE] é o nome do modelo de instância que você quer usar para criar esse grupo. O modelo precisa ter uma afinidade de nó que aponte para o grupo de nós pretendido.
    • [ZONE] é a zona em que o grupo de nós está localizado.

API

Crie um nó e as respectivas instâncias usando os métodos da API Compute Engine:

  1. Na API, crie uma solicitação GET para recuperar uma lista de tipos de nós disponíveis usando o método compute.nodetypes.list:

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

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • [ZONE] é a zona de onde você quer recuperar os tipos de nós disponíveis.
  2. Crie uma solicitação POST para o método compute.nodetemplates.insert a fim de criar um novo modelo de nó. Para maior flexibilidade, especifique uma propriedade nodeTypeFlexibility com os valores cpus e memory definidos como any, para permitir que o nó seja executado em qualquer tipo de nó disponível sem capacidade SSD local.

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

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • [REGION] é a zona de onde você quer recuperar os tipos de nós disponíveis.
    • [TEMPLATE_NAME] é um nome para o novo modelo de nó.

    Também é possível selecionar um tipo de nó específico a ser usado no modelo. Esse modelo é menos flexível, mas garante que você só crie nós caso eles atendam aos requisitos exatos de memória de vCPU e sistema.

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

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • [TEMPLATE_NAME] é um nome para o novo modelo de nó.
    • [NODE_TYPE] é o tipo de nó que você quer usar no modelo. Por exemplo, é possível especificar o tipo de nó n1-node-96-624 para criar um nó com 96 vCPUs e 624 GB de memória.
    • [REGION] é a região onde você usará esse modelo.
  3. Depois de criar o modelo, crie um grupo de nós. Use o 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]"
    }
    

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • [ZONE] é a zona em que esse grupo de nós está localizado. Essa zona precisa estar na mesma região que o modelo de nó que você está usando.
    • [TARGET_SIZE] é o número de nós que você quer criar no grupo.
    • [REGION] é a região onde o modelo de nó está localizado.
    • [TEMPLATE_NAME] é um nome para o novo modelo de nó.
    • [GROUP_NAME] é um nome para o novo grupo de nós.
    • [TEMPLATE_NAME] é o nome do modelo de nó que você quer usar para criar esse grupo.
  4. Depois de criar o grupo de nós, é possível criar instância nos grupos de nós usando o método compute.instances.insert. Especifique uma entrada nodeAffinities que aponte para o nome do grupo de nós. Por exemplo, é possível criar uma instância com um tipo de máquina personalizado:

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

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • [INSTANCE_NAME] é o nome da nova instância.
    • [ZONE] é a zona em que o grupo de nós está localizado.
    • [REGION] é a região em que estão localizados o modelo de nó e a sub-rede.
    • [IMAGE_FAMILY] é uma das famílias de imagens disponíveis.
    • [IMAGE_PROJECT] é o projeto de imagem a que essa família de imagens pertence.
    • [GROUP_NAME] é o nome do grupo de nós em que você quer localizar essa instância.
    • [VCPUS] é o número de vCPUs que você quer usar com essa instância.
    • [MEMORY] é a quantidade de memória para a instância em MB. Por exemplo, é possível especificar 5376MB.
    • [NETWORK] é o nome da rede para conectar a instância.
    • [SUBNETWORK] é o nome da sub-rede para conectar a instância.

    Também é possível criar grupos de instâncias gerenciadas dentro do grupo de nós. Crie um modelo de instância usando o método compute.instanceTemplates.insert e especifique uma entrada nodeAffinities que aponte para o nome do grupo de nós:

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

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • [INSTANCE_NAME] é o nome da nova instância.
    • [ZONE] é a zona em que o grupo de nós está localizado.
    • [REGION] é a região em que estão localizados o modelo de nó e a sub-rede.
    • [TEMPLATE_NAME] é o nome do novo modelo de instância.
    • [IMAGE_FAMILY] é uma das famílias de imagens disponíveis.
    • [IMAGE_PROJECT] é o projeto de imagem a que essa família de imagens pertence.
    • [GROUP_NAME] é o nome do grupo de nós em que você quer localizar essa instância.
    • [VCPUS] é o número de vCPUs que você quer usar com essa instância.
    • [MEMORY] é a quantidade de memória para a instância em MB. Por exemplo, é possível especificar 5376MB.
    • [NETWORK] é o nome da rede para conectar a instância.
    • [SUBNETWORK] é o nome da sub-rede para conectar a instância.

    Crie um grupo de instâncias usando o 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]"
    }
    

    em que:

    • [PROJECT_ID] é o ID do projeto.
    • [ZONE] é a zona em que o grupo de nós está localizado.
    • [INSTANCE_GROUP_NAME] é o nome desse grupo de instâncias.
    • [BASE_INSTANCE_NAME] é o nome do prefixo de cada uma das instâncias no grupo de instâncias gerenciadas.
    • [SIZE] é o número de instâncias de VM que você quer incluir nesse grupo. O grupo de nós precisa ter recursos suficientes para acomodar as instâncias nesse grupo de instâncias gerenciadas.
    • [INSTANCE_TEMPLATE] é o nome do modelo de instância que você quer usar para criar esse grupo. O modelo precisa ter uma afinidade de nó que aponte para o grupo de nós pretendido.

Opções de nó de locatário individual

Veja a seguir outras opções que podem ser especificadas para seus modelos de nó.

Opção de reinicialização mínima do servidor

A configuração desta opção especifica que, na ocorrência de um evento de manutenção, as VMs neste grupo de nós serão reiniciadas no mesmo servidor físico, se possível. Se o mesmo servidor físico não estiver disponível, um novo servidor físico será criado e adicionado ao grupo de nós.

Isso é diferente dos rótulos de afinidade de nó, que apenas garantem que determinadas VMs sejam criadas em nós com rótulos específicos. Isso não influencia se o servidor físico subjacente permanece o mesmo durante o ciclo de vida do grupo de nós.

Para especificar esta opção:

Console

Na página Criar um modelo de nó (em inglês), expanda a Configuração avançada de reinicialização do nó e selecione Servidores mínimos.

gcloud

Com a ferramenta gcloud, especifique a sinalização --server-binding restart-node-on-minimal-servers ao criar um modelo de nó.

API

Ao fazer uma solicitação HTTP direta, forneça o objeto serverBinding, com a string type: restart-node-on-minimal-servers como parte da solicitação ao criar um modelo de nó:

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

Como configurar a afinidade de nó

É possível definir afinidades ou antiafinidades de nó para determinar quais nós suas instâncias e grupos de instâncias gerenciadas usam como sistemas host. Ao definir afinidades de nó, você escolhe explicitamente quais nós de locatário individual hospedam quais VMs.

Por padrão, cada nó recebe os seguintes rótulos de afinidade:

  • Cada nó em um grupo tem um rótulo de afinidade que corresponde ao nome do grupo de nós:
    • Chave: compute.googleapis.com/node-group-name
    • Valor: o nome do grupo de nós.
  • Cada nó tem um rótulo de afinidade que corresponde ao nome próprio do nó. Os nomes de nós são gerados automaticamente:
    • Chave: compute.googleapis.com/node-name
    • Valor: o nome do nó individual.

É possível configurar outros rótulos de afinidade ou antiafinidade para que suas instâncias sejam executadas somente nos grupos de nós que você queira ou compartilhem nós somente com instâncias da mesma afinidade. Isso permite manter dados confidenciais juntos em grupos de nós específicos e separados dos outros grupos de nós e de outras instâncias de VM em execução no Compute Engine.

Por exemplo, talvez você queira criar um grupo de nós para desenvolvimento e um grupo de nós separado para cargas de trabalho de produção. É possível usar o seguinte processo:

  1. Crie dois modelos de nó com dois rótulos diferentes, workload=frontend,environment=prod e workload=frontend,environment=dev. O rótulo workload indica que esses grupos de nós são destinados a cargas de trabalho frontend e o rótulo environment distingue ambientes prod e 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. Crie diversos grupos de nós usando os modelos de produção e desenvolvimento. Por exemplo, convém ter um grupo de nós de produção grande e vários grupos de nós de desenvolvimento menores. Outra opção é criar esses grupos em zonas diferentes e com tamanhos de destino distintos, para acomodar a escala das cargas de trabalho:

    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 suas instâncias de produção, crie um arquivo node-affinity-prod.json para articular mais claramente como você pretende que a afinidade seja executada em suas instâncias de produção. Por exemplo, é possível criar um arquivo que instrui instâncias a serem executadas somente em nós com afinidades workload=frontend e environment=prod:

    [{
    "key" : "workload",
    "operator" : "IN",
    "values" : ["frontend"]
    },
    {
    "key" : "environment",
    "operator" : "IN",
    "values" : ["prod"]
    }
    ]
    
  4. Use o arquivo node-affinity-prod.json para criar um modelo de instância com as propriedades que você quer para suas instâncias de VM de produção:

    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. Inicie um grupo de instâncias usando o modelo de produção executado no nó de produção:

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

    As instâncias no grupo são iniciadas e executadas apenas nos grupos de nós com as afinidades workload=frontend e environment=prod.

Como configurar rótulos antiafinidade

O exemplo acima descreve como usar rótulos de afinidade. Também é possível aproveitar os rótulos antiafinidade para garantir que as VMs evitem nós com determinados rótulos. Suponha que, além das instâncias de VM de produção criadas acima, você também queira criar algumas instâncias de VM para fins de desenvolvimento, mas não precisa hospedá-las nos mesmos nós que hospedam suas instâncias de produção.

  1. Para instâncias de desenvolvimento, crie um arquivo node-affinity-dev.json para articular mais claramente como você quer que a afinidade em suas instâncias de desenvolvimento funcione. Por exemplo, é possível criar um arquivo que configure instâncias para serem executadas em qualquer grupo de nós com o parâmetro de afinidade workload=frontend, desde que ele não seja environment=prod:

    [{
    "key" : "workload",
    "operator" : "IN",
    "values" : ["frontend"]
    },
    {
    "key" : "environment",
    "operator" : "NOT",
    "values" : ["prod"]
    }
    ]
    
  2. Para o desenvolvimento, é possível criar uma instância individual para realizar testes, em vez de um grupo inteiro de instâncias. Use o arquivo node-affinity-dev.json para criar essa instância. Por exemplo, se você quiser testar uma imagem de desenvolvimento específica chamada development-image-1, crie a instância e configure as respectivas afinidades com o seguinte 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 instância é iniciada e executada somente nos grupos de nós que têm workload=frontend. No entanto, elas não serão executadas em nenhum grupo de nós configurado com a afinidade environment=prod.

Para criar configurações de afinidade próprias, elabore um modelo de nó e execute os nós com suas próprias chaves e valores de afinidade. Em seguida, configure as instâncias com seus próprios arquivos affinity.json que determinam em quais nós suas instâncias podem ser executadas.

A seguir