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

Prepara los nodos e implementa VCF con el kit de herramientas

En esta página, se describe cómo usar el kit de herramientas de VMware Solution en Google Cloud para preparar nodos de ESXi de equipos físicos, configurar las redes de vSwitch y los almacenes de datos de vSAN, y también implementar el dispositivo instalador de VMware Cloud Foundation (VCF).

Descripción general

El kit de herramientas de VMware Solution automatiza la configuración inicial de las instancias de ESXi en equipos físicos implementadas en tu proyecto de Google Cloud . Cuando se ejecuta desde una VM de jumpbox, el kit de herramientas realiza las siguientes acciones:

Verificación de credenciales de host y restablecimiento de contraseña: Se conecta a cada instancia de ESXi de equipos físicos y restablece la contraseña inicial de ESXi root al secreto de esxi-root-password almacenado en Secret Manager.
Configuración de red: Configura vSwitch0 y crea grupos de puertos con etiquetas de VLAN para la red del instalador de VCF.
Configuración de almacenamiento: Inicializa las SSD locales en un grupo de vsanDatastore.
Implementación del instalador de VCF: Descarga el dispositivo virtual abierto (OVA) del instalador de VCF desde el depósito sin conexión, implementa el dispositivo en un host ESXi de destino designado, inserta parámetros de red y DNS, y , luego, inicializa el instalador.

Elige una ruta de implementación

Puedes ejecutar el kit de herramientas con uno de los siguientes enfoques:

Ruta uno: Aprovisiona un jumpbox con Terraform (recomendado): Usa Terraform para aprovisionar una VM de jumpbox de Compute Engine dedicada dentro de la VPC del host de ESXi, la subred de VPC, la puerta de enlace de Cloud NAT y las reglas de firewall de SSH de Identity-Aware Proxy (IAP).
Ruta dos: Usa una VM de jumpbox existente: Ejecuta el kit de herramientas directamente desde una VM de Linux existente ubicada dentro de la VPC del host de ESXi en una subred con el Acceso privado a Google habilitado.

Antes de comenzar

Antes de ejecutar el kit de herramientas, completa los siguientes requisitos previos:

Permite las redes de subredes de capa 2 basadas en VLAN incluidas en la lista de entidades permitidas

La solución de VMware requiere que las subredes de tu red de nube privada virtual (VPC) tengan la propiedad Resolver máscara de subred configurada en Transmitir solo el rango principal con aprendizaje para admitir las herramientas de redes basadas en VLAN. Abre un ticket de asistencia en el Centro de asistencia de la consola deGoogle Cloud con la siguiente información:

Producto: Google Cloud VMware Engine
Prioridad: P2
Categoría: Conectividad de red
Impacto comercial: Pregunta técnica general
Proporciona más detalles: Allowlist L2 network connectivity for my project, junto con el ID del proyecto, el número del proyecto y la región y la zona de destino para la implementación

Para obtener más información sobre la compatibilidad con las redes basadas en VLAN, consulta Emulación de capa 2: transmisión de ARP y aprendizaje de MAC personalizado.

Habilita las APIs obligatorias

Debes tener un proyecto de Google Cloud activo con la facturación habilitada (puede ser el mismo proyecto de Google Cloud en el que residen los hosts de ESXi o un proyecto de jumpbox independiente). Habilita las siguientes APIs:

API de Compute Engine (compute.googleapis.com): para proyectos de host de ESXi y jumpbox
API de Identity and Access Management (IAM) (iam.googleapis.com): para el proyecto de jumpbox
API de Cloud Resource Manager (cloudresourcemanager.googleapis.com): para proyectos de host de ESXi y jumpbox
API de Cloud Identity-Aware Proxy (iap.googleapis.com): para el proyecto de jumpbox
API de Secret Manager (secretmanager.googleapis.com): para el proyecto de host de ESXi

Para habilitar las APIs con la CLI de gcloud, ejecuta el siguiente comando:

gcloud services enable \
    compute.googleapis.com \
    iam.googleapis.com \
    cloudresourcemanager.googleapis.com \
    iap.googleapis.com \
    secretmanager.googleapis.com \
    --project='PROJECT_ID'

Reemplaza PROJECT_ID por el ID de tu proyecto de Google Cloud de destino.

Configura los permisos de IAM

El flujo de trabajo del kit de herramientas usa las siguientes identidades y roles:

Invocador de Terraform: Es el usuario o la identidad de CI/CD que inicia terraform apply. Requiere el rol de creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator) en la cuenta de servicio de Terraform Runner si se actúa en nombre del ejecutor.
Ejecutor de Terraform: Es la identidad que aprovisiona la infraestructura de Terraform:
- Administrador de red de Compute (roles/compute.networkAdmin)
- Administrador de instancias de Compute v1 (roles/compute.instanceAdmin.v1)
- Administrador de seguridad de Compute (roles/compute.securityAdmin)
- Usuario de la cuenta de servicio (roles/iam.serviceAccountUser)
- Administrador de IAM del proyecto (roles/resourcemanager.projectIamAdmin) en el proyecto de destino (si se usa la administración automatizada de IAM con Terraform)
Usuario de SSH de Jumpbox: Es la identidad que se conecta a la VM de Jumpbox con IAP:
- Descriptor de acceso de recursos de túnel de IAP (roles/iap.tunnelResourceAccessor)
- Visualizador de Compute (roles/compute.viewer)
Ejecutor de secuencias de comandos de Jumpbox: Es el usuario o la cuenta de servicio que ejecuta la secuencia de comandos del kit de herramientas de Python en el jumpbox:
- Descriptor de acceso de secretos de Secret Manager (roles/secretmanager.secretAccessor)
- Administrador de Compute (roles/compute.admin)
- Administrador del proyecto de IAM (roles/resourcemanager.projectIamAdmin)
Agente de servicio de desvío de red de VMware Engine (P4SA) (service-PROJECT_NUMBER@gcp-sa-network-drift.):
- Administrador de red de Compute (roles/compute.networkAdmin)

Almacena credenciales en Secret Manager

El kit de herramientas recupera las contraseñas en el entorno de ejecución desde Secret Manager y usa el secreto esxi-root-password para restablecer la contraseña inicial de root en cada instancia de ESXi de equipos físicos. Crea secretos en tu proyecto de Google Cloud para la contraseña de ESXi root, la contraseña de VCF root y la contraseña de usuario local de VCF (admin):

# 1. Create Secret for ESXi Host Root Password
gcloud secrets create esxi-root-password \
    --replication-policy='automatic' \
    --project='PROJECT_ID'
echo -n 'YOUR_ESXI_ROOT_PASSWORD' | gcloud secrets versions add esxi-root-password \
    --data-file=- \
    --project='PROJECT_ID'
# 2. Create Secret for VCF Installer Root Password
gcloud secrets create vcf-root-password \
    --replication-policy='automatic' \
    --project='PROJECT_ID'
echo -n 'YOUR_VCF_ROOT_PASSWORD' | gcloud secrets versions add vcf-root-password \
    --data-file=- \
    --project='PROJECT_ID'
# 3. Create Secret for VCF Local User Password
gcloud secrets create vcf-localuser-password \
    --replication-policy='automatic' \
    --project='PROJECT_ID'
echo -n 'YOUR_VCF_ADMIN_PASSWORD' | gcloud secrets versions add vcf-localuser-password \
    --data-file=- \
    --project='PROJECT_ID'

Antes de ejecutar los comandos, reemplaza lo siguiente:

PROJECT_ID: Es el ID de tu proyecto deGoogle Cloud de destino.
YOUR_ESXI_ROOT_PASSWORD: Es la nueva contraseña de root que se establecerá en tus hosts de ESXi de equipos físicos, que reemplaza la contraseña de la instancia inicial.
YOUR_VCF_ROOT_PASSWORD: la contraseña de root para el dispositivo del instalador de VCF.
YOUR_VCF_ADMIN_PASSWORD: Es la contraseña del usuario administrador local para el dispositivo de instalación de VCF.

Aprovisiona un jumpbox con Terraform

Si no tienes un jumpbox existente con conectividad de red a tus hosts de ESXi, usa los módulos de Terraform proporcionados para implementar una VM de jumpbox.

Clona el repositorio del kit de herramientas

Clona el repositorio del kit de herramientas en tu estación de trabajo local:

mkdir -p ~/smve-toolkit
cd ~/smve-toolkit
git clone https://github.com/GoogleCloudPlatform/self-managed-vmware-solution-toolkit
cd self-managed-vmware-solution-toolkit/smve-toolkit-jumpbox-tf

Configura las variables de Terraform

Ve al directorio infrastructure y crea el archivo terraform.tfvars:

cd infrastructure
cp terraform.tfvars.example terraform.tfvars

Actualiza el archivo terraform.tfvars con los parámetros de tu proyecto:

project_id      = "PROJECT_ID"
region          = "REGION"
zone            = "ZONE" # Match target ESXi host zone
# Network configuration
create_subnet   = true
vpc_name        = "VPC_NAME"
subnet_name     = "smve-toolkit-subnet"
subnet_cidr     = "10.10.0.0/28" # Minimum /29 required
# Cloud NAT and egress
enable_internet = true
# Jumpbox VM instance
jumpbox_name    = "smve-toolkit-jumpbox"

En la siguiente tabla, se describen las variables de entrada clave de Terraform:

Variable	Requisito	Predeterminado	Descripción
`project_id`	Obligatorio	Ninguno	Es el ID del proyecto deGoogle Cloud en el que Terraform implementa la infraestructura.
`region`	Obligatorio	Ninguno	Región de destino Google Cloud(por ejemplo, `us-central1`).
`zone`	Opcional	`${region}-a`	Es la zona objetivo. Establece esta variable para que coincida con la zona de tus hosts de ESXi de Bare Metal y minimizar la latencia.
`vpc_name`	Condicional	`""`	Es el nombre de la red de VPC que aloja los nodos de ESXi. Es obligatorio si la variable `create_subnet` se establece en `true`.
`create_subnet`	Opcional	`true`	Establece en `true` para crear una subred nueva o en `false` para usar una subred existente.
`subnet_name`	Opcional	`"smve-toolkit-subnet"`	Es el nombre de la subred para la VM de jumpbox. Si la variable `create_subnet` se establece en `false`, la subred debe existir en la red `vpc_name`.
`subnet_cidr`	Condicional	`""`	Rango de CIDR de IPv4 principal (mínimo `/29`). Es obligatorio si la variable `create_subnet` se establece en `true`.
`enable_internet`	Opcional	`true`	Controla Cloud Router, Cloud NAT y la creación de rutas predeterminadas para la salida de Internet. Establece en `false` después de la configuración para desmantelar la puerta de enlace de NAT, el router y la ruta.
`jumpbox_name`	Opcional	`"smve-toolkit-jumpbox"`	Es el nombre de la VM de jumpbox de Compute Engine.
`machine_type`	Opcional	`"e2-micro"`	Es el tipo de máquina para la instancia de VM de jumpbox.
`boot_disk_size`	Opcional	`30`	Es el tamaño del disco de arranque en GB para la instancia de VM de jumpbox (mínimo 10 GB).
`boot_disk_type`	Opcional	`"pd-balanced"`	Es el tipo de disco persistente para el disco de arranque de jumpbox (`pd-balanced`, `pd-standard`, `pd-ssd`, `pd-extreme`).
`boot_disk_image`	Opcional	`"debian-cloud/debian-12"`	Familia de imágenes de disco de arranque del SO o imagen específica `self_link`.
`jumpbox_internal_ip`	Opcional	`""`	Dirección IPv4 interna estática (por ejemplo, `"10.10.0.5"`), nombre de IP reservada o URI. La configuración predeterminada es una dirección IP efímera dinámica.
`service_account_email`	Opcional	`""`	Es el correo electrónico de la cuenta de servicio personalizada que se conectará a la VM de jumpbox. La opción predeterminada es la cuenta de servicio predeterminada de Compute Engine.

Implementa la infraestructura de jumpbox

Inicializa y aplica la configuración de Terraform:

export GOOGLE_IMPERSONATE_SERVICE_ACCOUNT='TERRAFORM_RUNNER_SA' # Optional: set only if impersonating a runner service account
terraform init
terraform validate
terraform plan -out=tfplan
terraform apply tfplan

Reemplaza TERRAFORM_RUNNER_SA por la dirección de correo electrónico de la cuenta de servicio del ejecutor de Terraform.

Conéctate al jumpbox con IAP

Conéctate a la VM de jumpbox con el reenvío de TCP de IAP (no se requiere una dirección IP pública):

gcloud compute ssh smve-toolkit-jumpbox \
    --project='PROJECT_ID' \
    --zone='ZONE' \
    --tunnel-through-iap

Antes de ejecutar el comando, reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto de Google Cloud que aloja la VM de jumpbox.
ZONE: Es la zona de Google Cloud en la que se implementa la VM de jumpbox.

Usa una VM de jumpbox existente

Si traes una VM de jumpbox existente, debe ser una VM de Compute Engine de Linux ubicada dentro de la misma red de VPC que aloja los nodos de ESXi de Bare Metal. Este requisito de ubicación de la VPC es obligatorio para garantizar la conectividad de red con el extremo de Private Service Connect (PSC) del repositorio sin conexión que aloja el OVA del instalador de VCF.

Antes de ejecutar el kit de herramientas, verifica que tu VM de jumpbox existente cumpla con los siguientes requisitos:

Ubicación de la VPC: Debes implementar la VM dentro de la red de VPC que aloja los nodos de ESXi.
Acceso a la API deGoogle Cloud : La subred que aloja la VM de jumpbox debe tener habilitado el Acceso privado a Google (private_ip_google_access = true) o el acceso a Internet saliente para llegar a secretmanager.googleapis.com, compute.googleapis.com y iam.googleapis.com.
Salida de instalación de paquetes: Acceso HTTP/HTTPS saliente (con Cloud NAT, un proxy corporativo o salida directa) para instalar dependencias de Python.
Habilitación de la API y permisos de IAM: La identidad que ejecuta la secuencia de comandos debe tener los roles roles/secretmanager.secretAccessor, roles/compute.admin y roles/resourcemanager.projectIamAdmin en tu proyecto de Google Cloud .
Conectividad SSH: El jumpbox debe permitir la entrada de SSH en el puerto TCP 22 desde el rango de IP de IAP (35.235.240.0/20) o los rangos de IP públicos autorizados, y la identidad de conexión debe tener los roles aplicables (roles/iap.tunnelResourceAccessor y roles/compute.viewer).

Configura el kit de herramientas en el jumpbox

En la terminal de tu jumpbox, instala las dependencias y descarga la secuencia de comandos del kit de herramientas.

Instala paquetes del sistema

Instala Python 3, pip, venv y Git:

sudo apt-get update
sudo apt-get install -y python3 python3-pip python3-venv git

Obtén las secuencias de comandos del kit de herramientas

Clona el repositorio o copia las secuencias de comandos desde tu estación de trabajo local:

Opción A (clona con Git):

mkdir -p ~/smve-toolkit
cd ~/smve-toolkit
git clone https://github.com/GoogleCloudPlatform/self-managed-vmware-solution-toolkit
cd self-managed-vmware-solution-toolkit/python

Opción B (copia desde tu estación de trabajo local con gcloud compute scp):

gcloud compute scp --recurse ./smve-toolkit smve-toolkit-jumpbox:~/ \
  --project='PROJECT_ID' \
  --zone='ZONE' \
  --tunnel-through-iap
# On the jumpbox terminal, go to the copied folder:
cd ~/smve-toolkit/python

Crea y activa un entorno virtual de Python

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

Configura el archivo de configuración de la secuencia de comandos del kit de herramientas

Crea un archivo de configuración config.json en la VM de jumpbox para especificar tus instancias de ESXi de destino y la configuración de implementación de VCF.

Parámetros de configuración

Parámetro	Obligatorio	Tipo de dato	Descripción
`project`	Sí	`string`	ID del proyecto de destino de Google Cloud en el que residen las instancias de ESXi sin servidores.
`zone`	Sí	`string`	Zona de destino Google Cloud en la que residen los nodos de ESXi.
`gce_nodes`	Sí	`list(string)` o `object`	Lista explícita de nombres de instancias de ESXi de equipos físicos (por ejemplo, `["vcf-mgmt-sample-node-1", "vcf-mgmt-sample-node-2"]`) o un objeto que descubre instancias por `prefix` (por ejemplo, `{"prefix": "vcf-mgmt-sample"}`) o `subnet` (`{"subnet": "vcf-mgmt-subnet"}`).
`esxi_root_password_secret`	Sí	`string`	Es el nombre del Secret de Secret Manager o la ruta de acceso del recurso que contiene la contraseña raíz de ESXi.
`vcf_deployment_config`	Opcional	`object`	Es el objeto de configuración para la inicialización y la implementación del instalador de VCF. Omite este objeto si no necesitas implementar el instalador de VCF en ninguno de los nodos que se están preparando.
`└─ target_gce_node`	Condicional	`string`	Es el nodo de equipos físicos de destino que aloja las cargas de trabajo de implementación iniciales. Es obligatorio si se define el objeto `vcf_deployment_config`.
`└─ vcf_appliance_root_password_secret`	Condicional	`string`	Es el nombre del Secret de Secret Manager que contiene la contraseña raíz del dispositivo de VCF.
`└─ vcf_appliance_local_user_password_secret`	Condicional	`string`	Nombre del Secret de Secret Manager que contiene la contraseña del usuario local (administrador) del dispositivo de VCF.
`└─ vcf_installer_ip_source`	Condicional	`string` o bien `object`	Es la fuente de la dirección IP para el instalador de VCF (SDDC Manager). Especifica `{"reserved_address": "ADDRESS_NAME"}`, `{"forwarding_rule": "RULE_NAME"}` o una cadena de URI de recurso directo (por ejemplo, `projects/PROJECT_ID/regions/REGION/forwardingRules/RULE_NAME`).
`└─ vcf_installer_fqdn`	Condicional	`string`	Nombre de dominio completamente calificado (FQDN) para el instalador de VCF (SDDC Manager).
`└─ offline_depot_subnet_cidr`	Condicional	`string`	Es el rango CIDR IPv4 principal para la subred del depósito sin conexión dedicado (por ejemplo, `/29`). No debe superponerse con ninguna subred existente en la VPC ni reutilizarla.
`└─ dns_server`	Opcional	`string`	Dirección IP del servidor DNS (por ejemplo, la IP de DNS reservada de tu subred o un servidor DNS personalizado). Si se omite, el valor predeterminado es el servidor de metadatos deGoogle Cloud (`169.254.169.254`). Especifica una dirección IP de una subred que no sea de capa 2 si usas Cloud DNS.

Configuraciones de muestra

En las siguientes pestañas, se muestran configuraciones de config.json de ejemplo (basadas en plantillas disponibles en el directorio python/examples/) para diferentes enfoques de orientación de instancias y estrategias de asignación de IP:

Lista de nodos explícita

Usa esta configuración (python/examples/config_explicit_nodes.json) para orientar a nombres de instancias de ESXi específicos:

{
// Target Google Cloud project ID where bare-metal ESXi instances reside
"project": "PROJECT_ID",
// Target Google Cloud Compute Engine zone for ESXi instances
"zone": "us-east4-c",
// Explicit list of bare-metal ESXi Compute Engine instance names
"gce_nodes": [
  "vcf-mgmt-sample-node-1",
  "vcf-mgmt-sample-node-2",
  "vcf-mgmt-sample-node-3",
  "vcf-mgmt-sample-node-4"
],
// Secret Manager secret containing the ESXi root password
"esxi_root_password_secret": "esxi-root-password",
// Optional Jumpbox logging configuration (defaults to ~/logs/vcf_deployer_<timestamp>.log).
// DEBUG level is default for file logs and console level can be controlled by "log_level" (defaults to INFO).
// "log_dir": "~/logs",
// "log_file": "~/logs/vcf_deployer_custom.log",
// "log_level": "INFO",
// VCF deployment and initialization parameters
"vcf_deployment_config": {
  // Target bare-metal node hosting the initial deployment workloads
  "target_gce_node": "vcf-mgmt-sample-node-1",
  // IPv4 CIDR range for dedicated offline depot subnetwork (for example, /29). Must not overlap with or reuse any existing subnets in the VPC
  "offline_depot_subnet_cidr": "10.2.100.0/29",
  // Secret Manager secret containing the VCF appliance root password
  "vcf_appliance_root_password_secret": "vcf-root-password",
  // Secret Manager secret containing the VCF appliance local user password
  "vcf_appliance_local_user_password_secret": "vcf-localuser-password",
  // Source identifier for the VCF Installer (SDDC Manager) IP address
  "vcf_installer_ip_source": {
    "forwarding_rule": "vcf-mgmt-sddcm-fr"
  },
  // Fully qualified domain name for SDDC Manager / VCF Installer
  "vcf_installer_fqdn": "sddcm.gcve-vcf.test.gve",
  // DNS server IP. If gcp_subnet was created during Cloud DNS configuration from E2E TF, use the DNS reserved IP from that subnet. Otherwise, supply a custom DNS server IP. Defaults to Google Cloud metadata server (169.254.169.254) if omitted.
  "dns_server": "10.0.100.2"
}
}

Filtro de prefijo de nombre de nodo

Usa esta configuración (python/examples/config_prefix_filter.json) para descubrir de forma dinámica instancias de ESXi que coincidan con un prefijo de nombre y usar una regla de reenvío:

{
// Target Google Cloud project ID where bare-metal ESXi instances reside
"project": "PROJECT_ID",
// Target Google Cloud Compute Engine zone for ESXi instances
"zone": "us-east4-c",
// Discover ESXi instances matching a given instance name prefix
"gce_nodes": {
  "prefix": "vcf-mgmt-sample"
},
// Secret Manager secret containing the ESXi root password
"esxi_root_password_secret": "esxi-root-password",
// Optional Jumpbox logging configuration (defaults to ~/logs/vcf_deployer_<timestamp>.log).
// DEBUG level is default for file logs and console level can be controlled by "log_level" (defaults to INFO).
// "log_dir": "~/logs",
// "log_file": "~/logs/vcf_deployer_custom.log",
// "log_level": "INFO",
// VCF deployment and initialization parameters
"vcf_deployment_config": {
  // Target bare-metal node hosting the initial deployment workloads
  "target_gce_node": "esxi-node-0",
  // IPv4 CIDR range for dedicated offline depot subnetwork (for example, /29). Must not overlap with or reuse any existing subnets in the VPC
  "offline_depot_subnet_cidr": "10.2.100.0/29",
  // Secret Manager secret containing the VCF appliance root password
  "vcf_appliance_root_password_secret": "vcf-root-password",
  // Secret Manager secret containing the VCF appliance local user password
  "vcf_appliance_local_user_password_secret": "vcf-localuser-password",
  // Source identifier for the VCF Installer (SDDC Manager) forwarding rule
  "vcf_installer_ip_source": {
    "forwarding_rule": "vcf-mgmt-sddcm-fr"
  },
  // Fully qualified domain name for SDDC Manager / VCF Installer
  "vcf_installer_fqdn": "sddcm.gcve-vcf.test.gve",
  // DNS server IP. If gcp_subnet was created during Cloud DNS configuration from E2E TF, use the DNS reserved IP from that subnet. Otherwise, supply a custom DNS server IP. Defaults to Google Cloud metadata server (169.254.169.254) if omitted.
  "dns_server": "10.0.100.2"
}
}

Filtro de descubrimiento de subredes

Usa esta configuración (python/examples/config_subnet_filter.json) para descubrir de forma dinámica las instancias de ESXi conectadas a una subred específica y proporcionar un URI de recurso completo para la IP de origen:

{
// Target Google Cloud project ID where bare-metal ESXi instances reside
"project": "PROJECT_ID",
// Target Google Cloud Compute Engine zone for ESXi instances
"zone": "us-east4-c",
// Discover ESXi instances attached to a specific primary management subnet
"gce_nodes": {
  "subnet": "vcf-mgmt-subnet"
},
// Secret Manager secret containing the ESXi root password
"esxi_root_password_secret": "esxi-root-password",
// Optional Jumpbox logging configuration (defaults to ~/logs/vcf_deployer_<timestamp>.log).
// DEBUG level is default for file logs and console level can be controlled by "log_level" (defaults to INFO).
// "log_dir": "~/logs",
// "log_file": "~/logs/vcf_deployer_custom.log",
// "log_level": "INFO",
// VCF deployment and initialization parameters
"vcf_deployment_config": {
  // Target bare-metal node hosting the initial deployment workloads
  "target_gce_node": "esxi-node-0",
  // IPv4 CIDR range for dedicated offline depot subnetwork (for example, /29). Must not overlap with or reuse any existing subnets in the VPC
  "offline_depot_subnet_cidr": "10.2.100.0/29",
  // Secret Manager secret containing the VCF appliance root password
  "vcf_appliance_root_password_secret": "vcf-root-password",
  // Secret Manager secret containing the VCF appliance local user password
  "vcf_appliance_local_user_password_secret": "vcf-localuser-password",
  // Direct resource URI for the VCF Installer (SDDC Manager) forwarding rule
  "vcf_installer_ip_source": "projects/PROJECT_ID/regions/us-east4/forwardingRules/vcf-mgmt-sddcm-fr",
  // Fully qualified domain name for SDDC Manager / VCF Installer
  "vcf_installer_fqdn": "sddcm.gcve-vcf.test.gve",
  // DNS server IP. If gcp_subnet was created during Cloud DNS configuration from E2E TF, use the DNS reserved IP from that subnet. Otherwise, supply a custom DNS server IP. Defaults to Google Cloud metadata server (169.254.169.254) if omitted.
  "dns_server": "10.0.100.2"
}
}

Solo preparación de nodos (sin instalador de VCF)

Omite el objeto vcf_deployment_config en el archivo config.json si no necesitas implementar el dispositivo del instalador de VCF en ninguno de los nodos que se preparan (por ejemplo, cuando preparas nodos para la adición de nodos del día 2 o la creación de clústeres de datos de carga de trabajo):

{
"project": "PROJECT_ID",
"zone": "ZONE",
"gce_nodes": {
  "subnet": "SUBNET_NAME"
},
"esxi_root_password_secret": "esxi-root-password"
}

Reemplaza lo siguiente en tu archivo config.json (y quita los comentarios intercalados antes de ejecutar la secuencia de comandos de Python):

PROJECT_ID: el ID del proyecto de Google Cloud en el que residen tus instancias de ESXi de equipos físicos.
ZONE: Es la zona de Google Cloud en la que residen tus instancias de ESXi en equipos físicos (por ejemplo, us-east4-c).
SUBNET_NAME: Es el nombre de la subred de VPC conectada a tus instancias de ESXi (por ejemplo, vcf-mgmt-subnet).

Ejecuta la secuencia de comandos del kit de herramientas

Autentica con Google Cloud usando las credenciales predeterminadas de la aplicación en la terminal de jumpbox:

gcloud auth application-default login --no-browser

Con el entorno virtual activo (source venv/bin/activate) y config.json configurado, ejecuta el kit de herramientas:

python3 -m vcf_deployer.main --config config.json

Flujo de trabajo de ejecución

La secuencia de comandos ejecuta verificaciones de validación automatizadas y las siguientes etapas de configuración:

Validación previa: Confirma que las instancias de destino ejecuten imágenes de ESXi compatibles, valida el acceso a Secret Manager, verifica la alineación del CIDR de IP y calcula las huellas digitales de los certificados SSL.
Configuración de credenciales y restablecimiento de contraseña: Se conecta a cada host y restablece la contraseña inicial de ESXi root al secreto de esxi-root-password almacenado en Secret Manager.
Creación de vSwitch y grupos de puertos: Configura vSwitch0 y crea grupos de puertos con etiquetas de VLAN (vlan-VLAN_ID-RANDOM_SUFFIX).
Inicialización de vSAN: Formatea las SSD NVMe locales en un vsanDatastore.
Implementación del instalador de VCF: Implementa el OVA de VCF en target_gce_node, inserta la configuración de red y, luego, inicia el dispositivo.

Una vez que se complete la ejecución, desactiva el entorno virtual:

deactivate

Tareas posteriores a la implementación

Después de ejecutar el kit de herramientas y de implementar el dispositivo del instalador de VCF, realiza la siguiente configuración posterior a la implementación:

Inhabilitar la salida a Internet en el jumpbox (opcional)

Después de instalar las dependencias de Python, puedes desactivar Cloud NAT para aplicar una seguridad de salida estricta. En tu estación de trabajo terraform.tfvars, haz lo siguiente:

enable_internet = false

Vuelve a aplicar Terraform:

terraform apply

Revisa los problemas conocidos antes de continuar

Revisa todos los problemas documentados en la página Problemas conocidos antes de comenzar la implementación de VCF. Pasar por alto estos problemas puede causar fallas en la implementación.

Soluciona problemas

En esta sección, se describe cómo diagnosticar y resolver problemas comunes cuando configuras o ejecutas el kit de herramientas.

Inspecciona los registros de ejecución del kit de herramientas en el jumpbox

Cuando ejecutas el kit de herramientas en el jumpbox, la secuencia de comandos de Python escribe registros de ejecución detallados en el directorio ~/logs/ del directorio principal del jumpbox. Cada archivo de registro se llama vcf_deployer_TIMESTAMP.log. Si falla un paso de preparación del nodo o de implementación del instalador de VCF, inspecciona el archivo vcf_deployer_*.log más reciente en ~/logs/ para diagnosticar la falla.

Falla en la implementación del instalador de VCF debido a contraseñas poco seguras

Síntoma: La secuencia de comandos del kit de herramientas de Python falla o se comporta de forma inesperada durante la implementación y la inicialización del instalador de VCF.
Resolución: No ingreses contraseñas poco seguras para los usuarios de VCF en Secret Manager, ya que las contraseñas poco seguras pueden hacer que falle la secuencia de comandos de Python para la implementación del instalador de VCF. Asegúrate de que todas las contraseñas cumplan con los lineamientos de complejidad de contraseñas de Broadcom.

Permiso denegado (`roles/iam.serviceAccountTokenCreator`)

Síntoma: Errores durante la identidad temporal como cuenta de servicio mientras se ejecuta Terraform.
Resolución: Asegúrate de que la identidad que ejecuta Terraform tenga roles/iam.serviceAccountTokenCreator otorgado en la cuenta de servicio del ejecutor de Terraform.

Falla de conexión SSH de IAP (403 Prohibido / tiempo de espera agotado)

Síntoma: gcloud compute ssh no puede establecer un túnel de IAP.
Resolución:
- Verifica que la API de Cloud Identity-Aware Proxy (iap.googleapis.com) esté habilitada.
- Asegúrate de que tu identidad de usuario tenga roles/iap.tunnelResourceAccessor y roles/compute.viewer.
- Verifica que exista la regla de firewall allow-iap-ssh-* y que permita la entrada desde 35.235.240.0/20 en el puerto TCP 22.

Advertencia de eliminación de subred cuando se vuelve a aplicar (marca `create_subnet`)

Síntoma: Ejecutar terraform apply después de configurar enable_internet = false intenta destruir la subred.
Resolución: Conserva create_subnet = true si Terraform creó la subred. Cambiar create_subnet a false le indica a Terraform que deje de administrar el recurso y lo programe para su eliminación.

¿Qué sigue?

Si preparaste los nodos y, además, implementaste un instalador de VCF para la implementación del dominio de administración:
1. Configura la conexión al depósito regional sin conexión en el instalador de VCF para descargar los paquetes de software necesarios:
  - Protocolo: HTTPS
  - FQDN (no uses una dirección IP): offline-depot.REGION.selfmanagedvmwareengine.goog (reemplaza REGION por la región de Google Cloud en la que residen tus nodos de equipos físicos)
  - Puerto: 443
  - Nombre de usuario: vcf-depot-user
  - Contraseña: Google1!
2. Implementa el dominio de administración:
  - Si aprovisionaste tus recursos de Google Cloud con los módulos de Terraform de extremo a extremo (Implementa nodos y VCF con Terraform y el kit de herramientas), convierte el resultado de Terraform de management_domain_deployment_input_config en JSON con la secuencia de comandos auxiliar (scripts/export_deployment_config.py), reemplaza todos los campos marcados como user_should_input por tus valores de destino y proporciona el archivo JSON al instalador de VCF.
  - Si aprovisionaste tus recursos de Google Cloud sin usar los módulos de Terraform de extremo a extremo, proporciona las entradas de configuración del dominio de administración de forma manual en el instalador de VCF.
  - Para obtener instrucciones sobre cómo completar el flujo de trabajo de puesta en marcha del instalador de VCF, consulta Implementa una flota de VCF nueva o una instancia de VCF nueva en la documentación de Broadcom.
Si preparaste los nodos para agregarlos a un clúster existente, agrega los nodos preparados a tu clúster de VMware VCF 9.x con la IU o las APIs de VMware.
Obtén más información para agregar y quitar nodos en Administra la capacidad de los nodos o Administra la capacidad de los nodos con Terraform.