Use um script de arranque em VMs do Linux

Este documento explica como usar scripts de arranque para iniciar uma instância de máquina virtual (VM) e os respetivos programas associados no Google Distributed Cloud (GDC) air-gapped.

Um script de arranque é uma ferramenta de automatização que realiza tarefas durante o processo de arranque da VM. Use scripts de arranque para automatizar tarefas de configuração e implementação de VMs em instâncias novas ou existentes, o que lhe poupa tempo e reduz o esforço de configuração manual.

Este documento destina-se a programadores em grupos de administradores de plataformas ou operadores de aplicações que querem usar scripts de arranque para VMs num ambiente do Distributed Cloud. Para mais informações, consulte o artigo Públicos-alvo para a documentação do GDC air-gapped.

Antes de começar

Para usar comandos da interface de linhas de comandos (CLI) gdcloud, certifique-se de que transferiu, instalou, e configurou a CLI gdcloud. Todos os comandos do Distributed Cloud usam a CLI gdcloud ou kubectl e requerem um ambiente de sistema operativo (SO).

Obtenha o caminho do ficheiro kubeconfig

Para executar comandos no servidor da API Management, certifique-se de que tem os seguintes recursos:

1. Inicie sessão e gere o ficheiro kubeconfig para o servidor da API Management, se não tiver um.

2. Use o caminho para o ficheiro kubeconfig do servidor da API Management para substituir MANAGEMENT_API_SERVER nestas instruções.

Peça funções de IAM

Para usar scripts de arranque para uma VM, contacte o administrador de IAM do projeto para pedir as seguintes funções no seu projeto:

• Administrador do projeto de máquinas virtuais (project-vm-admin): crie, modifique, liste e elimine VMs no espaço de nomes do projeto.

• Administrador de segredos (secret-admin): obtenha, liste, crie, atualize, elimine, aplique patches e monitorize segredos do Kubernetes no espaço de nomes do projeto. Use esta função para especificar segredos de scripts de arranque. Não precisa desta função para especificar scripts de arranque de texto simples.

Todas as funções de VM têm de ser associadas ao espaço de nomes do projeto onde a VM reside. Siga os passos para validar o seu acesso.

Transmita um script de arranque

Pode usar scripts bash ou não bash como scripts de arranque. Para tal, inclua #!/bin/… no início do script para indicar o intérprete de scripts. Por exemplo, para usar um script de arranque Python 3, adicione #! /usr/bin/python3 ao início do script.

O Google Distributed Cloud (GDC) air-gapped executa scripts de arranque pela ordem em que aparecem na matriz startupScripts.

A tabela seguinte mostra o formato de script a usar com base no tamanho do script:

Tamanho do script	Formato do script
Scripts até 2048 bytes	Texto simples
Scripts com mais de 2048 bytes	Segredo do Kubernetes

Defina um script de arranque

Para usar um script de arranque, tem de adicionar o campo startupScripts ao campo spec da VM. Neste campo, pode especificar vários scripts de arranque como texto simples ou como um segredo do Kubernetes.

O exemplo seguinte especifica os scripts de arranque como texto simples e um segredo do Kubernetes:

apiVersion: virtualmachine.gdc.goog/v1
kind: VirtualMachine
metadata:
  name: "my-vm"
spec:
  # …
  startupScripts:
  - name: hello-world
    script: |
      #!/bin/bash
      echo hello
  - name: add-user
    scriptSecretRef:
      name: add-user
---

apiVersion: v1
kind: Secret
type: Opaque
metadata:
  name: add-user
data:
  script:
    IyEvYmluL2Jhc2gKYWRkdXNlciB1c2VyCg==

Reveja as seguintes considerações:

• O script de arranque é executado em todos os arranques.
• O script de arranque tem privilégios de raiz predefinidos.
• No segredo do Kubernetes, o nome do scriptSecretRef na spec da VM tem de corresponder ao campo metadata.name.
• No segredo do Kubernetes, especifique o conteúdo do script de arranque adicionando uma chave script ao campo data.

Crie uma nova VM com um script de arranque

Estas instruções aplicam-se independentemente do que usar como imagem para criar a sua VM. Conclua o seguinte:

1. Para criar um script de arranque como um segredo do Kubernetes, execute:

   cat <<EOF >>FILE_NAME
   STARTUP_SCRIPT_CONTENT
   EOF
   

   kubectl --kubeconfig MANAGEMENT_API_SERVER \
     -n PROJECT \
     create secret generic SECRET_NAME \
     --from-file=script=FILE_NAME
   

   rm FILE_NAME
   

2. Consulte os passos para criar uma VM conforme descrito na página Criar uma VM. No passo 1, adicione o script ou os scripts de arranque ao campo spec antes de executar o comando para criar uma VM.

   Este exemplo define um script de arranque com texto simples e um segredo do Kubernetes:

   apiVersion: virtualmachine.gdc.goog/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
     namespace: PROJECT
   spec:
     # …
     startupScripts:
     - name: CLEAR_TEXT_SCRIPT_NAME
       script: |
         #!/bin/bash
         CLEAR_TEXT_SCRIPT
     - name: SECRET_SCRIPT_NAME
       scriptSecretRef:
         name: SECRET_NAME
   

   Estas variáveis são definidas da seguinte forma:

   Variável	Definição
   MANAGEMENT_API_SERVER	O ficheiro kubeconfig do servidor da API Management.
   PROJECT	O projeto do Distributed Cloud no qual quer criar a VM.
   VM_NAME	O nome da VM.
   FILE_NAME	O nome do ficheiro para armazenar o script de arranque.
   STARTUP_SCRIPT_CONTENT	Os comandos a executar como parte do script de arranque
   CLEAR_TEXT_SCRIPT_NAME	O nome do script de arranque de texto simples.
   CLEAR_TEXT_SCRIPT	O script de texto simples que define.
   SECRET_NAME	O nome do segredo do Kubernetes.
   SECRET_SCRIPT_NAME	O nome do script de arranque como um segredo do Kubernetes.

3. Siga os passos para criar uma VM.

   Segue-se um exemplo de como criar uma VM com scripts de arranque que adicionam um novo utilizador através de um segredo do Kubernetes e texto simples.

   kubectl --kubeconfig MANAGEMENT_API_SERVER \
     -n PROJECT \
     apply -f - <<EOF
   apiVersion: virtualmachine.gdc.goog/v1
   kind: VirtualMachineDisk
   metadata:
     name: VM_BOOT_DISK_NAME
   spec:
     source:
       image:
         name: BOOT_DISK_IMAGE_NAME
         namespace: vm-system
     size: BOOT_DISK_SIZE
   ---
   apiVersion: v1
   kind: Secret
   type: Opaque
   metadata:
     name: add-user
   data:
     script:
       IyEvYmluL2Jhc2gKYWRkdXNlciB1c2VyCg==
   ---
   apiVersion: virtualmachine.gdc.goog/v1
   kind: VirtualMachine
   metadata:
     name: VM_NAME
   spec:
     compute:
       virtualMachineType: MACHINE_TYPE
     disks:
     - virtualMachineDiskRef:
         name: VM_BOOT_DISK_NAME
       boot: true
       autoDelete: BOOT_DISK_AUTO_DELETE
     startupScripts:
     - name: add-user
       scriptSecretRef:
         name: add-user
     - name: add-to-sudoers
       script: |
         #!/bin/bash
         usermod -aG sudo user
   EOF
   

   No exemplo, as variáveis são definidas da seguinte forma.

   Variável	Definição
   MANAGEMENT_API_SERVER	O ficheiro kubeconfig do servidor da API Management.
   PROJECT	O projeto do Distributed Cloud no qual quer criar a VM.
   VM_NAME	O nome da nova VM.
   VM_BOOT_DISK_NAME	O nome do novo disco de arranque da VM.
   BOOT_DISK_IMAGE_NAME	O nome da imagem a usar para o novo disco de arranque da VM.
   BOOT_DISK_SIZE	O tamanho do disco de arranque, como 20G. Este valor tem de ser sempre superior ou igual ao minimumDiskSize da imagem do disco de arranque.
   BOOT_DISK_AUTO_DELETE	`true` ou `false`, que indica se o disco de arranque ` ` é eliminado automaticamente quando a instância de VM é eliminada.
   MACHINE_TYPE	O tipo de máquina predefinido para a nova VM. Para selecionar um tipo de máquina disponível, execute este comando: kubectl --kubeconfig MANAGEMENT_API_SERVER get virtualmachinetype.virtualmachine.gdc.goog --namespace vm-system

Atualize uma VM existente com um script de arranque

Também pode atualizar uma VM existente com um script de arranque. A VM tem de ser encerrada antes de fazer a atualização.

Siga os passos para atualizar as propriedades da VM e atualizar o campo spec com o script de arranque que quer executar.

Veja a saída de um script de arranque

1. Siga os passos para se ligar a uma VM.

2. Execute o seguinte comando na VM convidada para obter os registos do script de arranque que executou:

   sudo journalctl -u cloud-final
   

   Os registos do script de arranque começam com o seguinte:

   Started to run the command: /var/lib/google/startup-scripts/<script-name> ...