Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Usa una secuencia de comandos de inicio con una instancia de VM en VMs de Linux

Una secuencia de comandos de inicio realiza tareas durante el proceso de inicio de una máquina virtual (VM). En esta página, se proporcionan los pasos que debes seguir para usar secuencias de comandos de inicio en instancias de VM.

Antes de comenzar

Para usar los comandos de la interfaz de línea de comandos (CLI) de gdcloud, asegúrate de haber descargado, instalado, y configurado la CLI de gdcloud. Todos los comandos para el dispositivo aislado de GDC usan la CLI de gdcloud o kubectl y requieren un entorno de sistema operativo (SO).

Obtén la ruta de acceso del archivo kubeconfig

Para ejecutar comandos en el servidor de la API de Management, asegúrate de tener los siguientes recursos:

Ubica el nombre del servidor de la API de Management o pregúntale a tu administrador de la plataforma (PA) cuál es el nombre del servidor.
Accede y genera el archivo kubeconfig para el servidor de la API de Management si no tienes uno.
Usa la ruta de acceso para reemplazar MANAGEMENT_API_SERVER{"</var>"}} en estas instrucciones.

Solicita roles de IAM

Para usar secuencias de comandos de inicio para una VM, comunícate con tu administrador de IAM del proyecto para solicitar los siguientes roles en tu proyecto:

Administrador de VirtualMachine del proyecto (project-vm-admin): Crea, modifica, enumera y borra VMs en el espacio de nombres del proyecto.
Administrador de Secret (secret-admin): Obtén, enumera, crea, actualiza, borra, aplica parches y observa los secretos de Kubernetes en el espacio de nombres del proyecto. Usa este rol para especificar secretos de secuencias de comandos de inicio. No necesitas este rol para especificar secuencias de comandos de inicio de texto simple.

Todos los roles de VM deben vincularse al espacio de nombres del proyecto en el que reside la VM. Sigue los pasos para verificar tu acceso.

Pasa una secuencia de comandos de inicio

Puedes usar secuencias de comandos bash o no bash como secuencias de comandos de inicio. Para ello, incluye #!/bin/… al comienzo de la secuencia de comandos para indicar el intérprete de la secuencia de comandos. Por ejemplo, para usar una secuencia de comandos de inicio de Python 3, agrega #! /usr/bin/python3 al comienzo de la secuencia de comandos.

El dispositivo aislado de Google Distributed Cloud (GDC) ejecuta secuencias de comandos de inicio en orden alfabético, según el nombre de cada secuencia de comandos de inicio.

En la siguiente tabla, se muestra el formato de secuencia de comandos que se debe usar según el tamaño de la secuencia de comandos:

Tamaño de la secuencia de comandos	Formato de la secuencia de comandos
Secuencias de comandos de hasta 2048 bytes	Texto simple
Secuencias de comandos de más de 2048 bytes	Secreto de Kubernetes

Define una secuencia de comandos de inicio

Para usar una secuencia de comandos de inicio, debes agregar el campo startupScripts al campo spec de la VM. Dentro de este campo, puedes especificar varias secuencias de comandos de inicio como texto simple o como un secreto de Kubernetes.

En el siguiente ejemplo, se especifican las secuencias de comandos de inicio como texto simple y un secreto de 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==

Revisa las siguientes consideraciones:

La secuencia de comandos de inicio se ejecuta en cada inicio.
La secuencia de comandos de inicio tiene privilegios raíz predeterminados.
En el secreto de Kubernetes, el nombre de scriptSecretRef en la spec de la VM debe coincidir con el campo metadata.name.
En el secreto de Kubernetes, especifica el contenido de la secuencia de comandos de inicio agregando una clave script al campo data.

Crea una VM nueva con una secuencia de comandos de inicio

Estas instrucciones se aplican independientemente de lo que uses como imagen para crear tu VM. Completa la siguiente información:

Para crear una secuencia de comandos de inicio como un secreto de Kubernetes, ejecuta lo siguiente:

cat <<EOF >>FILE_NAME
STARTUP_SCRIPT_CONTENT
EOF

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

rm FILE_NAME

Consulta los pasos para crear una VM como se describe en la página Crea una VM. En el paso uno, agrega la secuencia de comandos de inicio o las secuencias de comandos al campo spec antes de ejecutar el comando para crear una VM.

En este ejemplo, se define una secuencia de comandos de inicio con texto simple y un secreto de 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 variables se definen de la siguiente manera:

Variable	Definición
`MANAGEMENT_API_SERVER`	El archivo `kubeconfig` del servidor de la API de Management.
`PROJECT`	El proyecto del dispositivo aislado de GDC en el que deseas crear la VM.
`VM_NAME`	El nombre de la VM.
`FILE_NAME`	El nombre del archivo para almacenar la secuencia de comandos de inicio.
`STARTUP_SCRIPT_CONTENT`	Los comandos que se ejecutarán como parte de la secuencia de comandos de inicio
`CLEAR_TEXT_SCRIPT_NAME`	El nombre de la secuencia de comandos de inicio de texto simple.
`CLEAR_TEXT_SCRIPT`	La secuencia de comandos de texto simple que defines.
`SECRET_NAME`	El nombre del secreto de Kubernetes.
`SECRET_SCRIPT_NAME`	El nombre de la secuencia de comandos de inicio como un secreto de Kubernetes.

Continúa con los siguientes pasos para crear una VM.

El siguiente es un ejemplo de cómo crear una VM con secuencias de comandos de inicio que agrega un usuario nuevo con un secreto de Kubernetes y texto simple.

kubectl --kubeconfig MANAGEMENT_API_SERVER \
    apply -n PROJECT -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

En el ejemplo, las variables se definen de la siguiente manera.

Variable	Definición
`MANAGEMENT_API_SERVER`	El archivo `kubeconfig` del servidor de la API de Management.
`PROJECT`	El proyecto del dispositivo aislado de GDC en el que deseas crear la VM.
`VM_NAME`	El nombre de la VM nueva.
`VM_BOOT_DISK_NAME`	El nombre del disco de arranque de la VM nueva.
`BOOT_DISK_IMAGE_NAME`	El nombre de la imagen que se usará para el disco de arranque de la VM nueva.
`BOOT_DISK_SIZE`	El tamaño del disco de arranque, como `20G`. Este valor siempre debe ser mayor o igual que el `minimumDiskSize` de la imagen del disco de arranque.
`BOOT_DISK_AUTO_DELETE`	`true` o `false`, lo que indica si el disco de arranque se borra automáticamente cuando se borra la instancia de VM.`truefalse`
`MACHINE_TYPE`	El tipo predefinido de máquina para la VM nueva. Para seleccionar un tipo de máquina disponible, ejecuta este comando: `kubectl --kubeconfig MANAGEMENT_API_SERVER get virtualmachinetype.virtualmachine.gdc.goog --namespace vm-system`

Actualiza una VM existente con una secuencia de comandos de inicio

También puedes actualizar una VM existente con una secuencia de comandos de inicio. La VM debe apagarse antes de realizar la actualización.

Sigue los pasos para actualizar las propiedades de la VM y actualizar el campo spec con la secuencia de comandos de inicio que deseas ejecutar.

Visualiza el resultado de una secuencia de comandos de inicio

Sigue los pasos para conectarte a una VM.
Ejecuta el siguiente comando dentro de la VM invitada para obtener los registros de la secuencia de comandos de inicio que ejecutaste:
```
sudo journalctl -u cloud-final
```
Los registros de secuencias de comandos de inicio comienzan con lo siguiente:
```
Started to run the command: /var/lib/google/startup-scripts/<script-name> ...
```

Usa una secuencia de comandos de inicio con una instancia de VM en VMs de Linux Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.