Como criar nós de locatário individual

Crie nodes de locatário único para separar fisicamente suas instâncias das instâncias de outros projetos. Cada node é associado a um servidor físico e é o único node em execução nesse servidor. Dentro dos nodes, execute várias instâncias de diversos tamanhos sem compartilhar o hardware de host com outros projetos. Os nodes podem migrar ativamente para um sistema de host totalmente novo sem parar as instâncias de VM de host.

Consulte os preços de node de locatário único para saber como calcular preços e descontos para esse tipo de node.

Leia a visão geral dos nodes de locatário único para saber os benefícios, os casos de uso e os recursos desses nodes.

Antes de começar

Restrições

Revise a seção Restrições na visão geral dos 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 único requer o seguinte processo:

  1. Crie um modelo de nó, que especifica o tipo de nó ou os requisitos de vCPU e memória. Além disso, especifique uma região e marcadores opcionais de afinidade de nó.
  2. Use o modelo para criar um grupo com um ou mais nodes de locatário único. Reduza o número de nodes 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 predefinida ou personalizada. 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 node para definir as propriedades dos nodes em um grupo. Depois de criar o modelo, você poderá usá-lo para criar um ou mais grupos de nodes. Depois, crie novas instâncias nesses grupos de nodes.

Console

Crie um node e as respectivas instâncias usando o console do Google Cloud Platform:

  1. Acesse a página de nodes de locatário individual.

    Acessar a página de nodes de locatário individual

  2. Clique em Criar um modelo de node para começar a criar um modelo de node.
  3. Especifique a região onde você planeja executar um grupo de node.
  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 node para criar um grupo de node.

  1. Acesse a página de nodes de locatário individual.

    Acessar a página de nodes de locatário individual

  2. Clique em Criar grupo de node para começar a criar um grupo de node.
  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 node ou em nodes 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 node.

  1. Acesse a página de nodes de locatário individual.

    Acessar a página de nodes 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 que tipos de nó estão disponíveis para você:

    gcloud compute sole-tenancy node-types list
    

    Periodicamente, o Compute Engine substituirá 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 terá que fazer upgrade dos seus modelos de nó 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ó disponíveis mudará com o passar do tempo, configure os modelos de nó para usar requisitos de tipo de nó flexível. Por exemplo, especifique --node-requirements vCPU=any,memory=any,localSSD=0, que 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 node específico a ser usado no modelo. Esse modelo é menos flexível, mas garante que você só crie nodes 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, especifique o tipo de nó n1-node-96-624 para criar um com 96 vCPUs e 624 GB de memória;
    • [REGION] é a região em que 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 nodes;
    • [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 nesses grupos 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 na API do Compute Engine Beta:

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

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

    em que:

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

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

    em que:

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

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

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

    em que:

    • [PROJECT_ID] é o código 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, especifique o tipo de nó n1-node-96-624 para criar um com 96 vCPUs e 624 GB de memória;
    • [REGION] é a região em que 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://www.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 código 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 em que o modelo de nós 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, será possível criar instâncias nele 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://www.googleapis.com/compute/v1/projects/[PROJECT_ID]/zones/[ZONE]/instances

    {
     "machineType": "/zones/[ZONE]/machineTypes/custom-[VCPUS]-[MEMORY]",
     "name": "[INSTANCE_NAME]",
     "scheduling": {
      "nodeAffinities": [
       {
        "key": "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 código 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 o modelo de nó e a sub-rede estão localizados;
    • [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.instancetempates.insert e especifique uma entrada nodeAffinities que aponte para o nome do grupo de nodes:

    POST https://www.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": "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 código 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 o modelo de nó e a sub-rede estão localizados;
    • [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://www.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 código do projeto;
    • [ZONE] é a zona onde o grupo de nodes 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.

Como configurar a afinidade de nó

A afinidade de node determina os nodes que as instâncias e os grupos de instâncias gerenciadas usam como sistemas de host. Por padrão, cada nó tem os seguintes marcadores 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ão gerados automaticamente:
    • Chave: compute.googleapis.com/node-name
    • Valor: o nome do node individual.

Configure marcadores adicionais de afinidade ou antiafinidade. Dessa maneira, as instâncias são executadas apenas nos grupos de nodes que você quer ou compartilham os nodes somente com instâncias do mesmo tipo de afinidade. Isso permite manter dados confidenciais juntos em grupos de nodes específicos e separados dos outros grupos de nodes e de outras instâncias de VM em execução no Compute Engine.

Por exemplo, a fim de 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 se destinam a cargas de trabalho frontend, e o rótulo environment diferencia ambientes prod de 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 node-groups create production-group \
        --node-template production-template --target-size 5 --zones us-west1-b
    
    gcloud compute node-groups create development-group-east1 \
        --node-template development-template --target-size 1 --zones us-east1-d
    
    gcloud compute node-groups create development-group-east2 \
        --node-template development-template --target-size 1 --zones us-east1-d
    
  3. Para as instâncias de produção, crie um arquivo node-affinity-prod.json para definir mais claramente como você quer executar a afinidade nas instâncias de produção. Por exemplo, é possível criar um arquivo especificando que as instâncias sejam executadas apenas em nós com as 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 a fim de criar um modelo de instância com as propriedades que você quiser para as 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 são executadas apenas nos grupos de nós que têm as afinidades workload=frontend e environment=prod.

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

    [{
    "key" : "workload",
    "operator" : "IN",
    "values" : ["frontend"]
    },
    {
    "key" : "environment",
    "operator" : "NOT",
    "values" : ["prod"]
    }
    ]
    
  7. 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, para 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
    

    Essa instância é iniciada e executada apenas nos grupos de nós que têm a workload=frontend. No entanto, ela não será executada em nenhum grupo de nós configurado com a afinidade environment=prod.

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

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Compute Engine