Imágenes de máquinas personalizadas de Windows

En este tema se describe cómo crear una imagen de máquina personalizada Windows que Tanzu Kubernetes Grid (TKG) puedan utilizar para crear y administrar clústeres de carga de trabajo que ejecutan cargas de trabajo basadas en Windows en nodos de trabajo de Windows.

Si va a crear una aplicación basada en componentes de Windows heredados (como .NET Framework) y desea implementar contenedores Windows en vSphere, siga este procedimiento para crear una imagen de máquina personalizada de Windows. Se divide en las siguientes secciones:

Requisitos previos de imagen de Windows muestra el entorno y los archivos que necesita para compilar y utilizar correctamente una imagen de Windows.
Compilar una imagen Windows muestra cómo utilizar Kubernetes Image Builder y Docker para personalizar y compilar una imagen de Windows.
Utilizar una imagen de Windows para un clúster de carga de trabajo muestra cómo implementar un clúster de carga de trabajo que utiliza la imagen de Windows como plantilla.

Nota
VMware no admite clústeres de carga de trabajo de TKG con nodos de trabajo Windows en entornos con proxy o aislados.

Requisitos previos de imagen de Windows

Para crear una imagen de máquina personalizada, necesita:

vSphere 7 o superior.
Una estación de trabajo Linux.

Nota
Debido a un problema con la utilidad packer de código abierto utilizada por Kubernetes Image Builder, no se puede crear una imagen de máquina Windows en una máquina MacOS.
Escritorio de Docker. Para instalar, consulte la página de descarga de productos Docker. Utilice apt en lugar de snap para instalar Docker desde una CLI.
CLI de Tanzu. Para instalar, consulte Instalar la CLI de Tanzu en Instalar la CLI de Tanzu y la CLI de Kubernetes para su uso con clústeres de administración independientes.
Un clúster de administración independiente de TKG v2.3.
- Cree un clúster de administración siguiendo el procedimiento descrito en Implementar clústeres de administración con la interfaz del instalador.
Una imagen ISO reciente (posterior a abril de 2021) Windows Server 2019. Descargue a través de su cuenta de Microsoft Developer Network (MSDN) o Volume Licensing (VL). No se admite ni se recomienda el uso de medios de evaluación.
La imagen ISO más reciente de VMware Tools Windows. Descargar de VMware Tools.
Un almacén de datos en vCenter que pueda alojar la plantilla de máquina virtual Windows personalizada, que puede tener un tamaño inicial superior a 10 GB (aprovisionamiento fino).

Crear una imagen de Windows

Importe la imagen Ubuntu o Photon OVA en vCenter para usarla como plantilla para la imagen personalizada siguiendo estos pasos:
1. Vaya a VMware Customer Connect e inicie sesión con las credenciales de VMware Customer Connect.
2. Vaya a Descargas de productos de Tanzu Kubernetes Grid v2.3.1.
3. Desplácese hasta la sección denominada OVA de Kubernetes para VMware Tanzu Kubernetes Grid 2.3, busque Ubuntu 2004 Kubernetes v1.26.8 OVA o Photon v3 Kubernetes v1.26.8 OVA y haga clic en Descargar ahora (Download Now).
4. Inicie sesión en vCenter.
5. Haga clic con el botón secundario en el host o clúster, y haga clic en Implementar plantilla de OVF… para importar la imagen.
6. Haga clic con el botón secundario en la imagen importada, pase el cursor sobre Plantilla (Template) y haga clic en Convertir en plantilla (Convert to Template).
7. Para asegurarse de que la plantilla esté lista para usarse, seleccione el host o el clúster, seleccione la pestaña VM y, a continuación, seleccione Plantillas de máquina virtual (VM Templates)para ver la plantilla en la lista.
Importe las imágenes Windows Server 2019 ISO y VMware Tools Windows ISO en el almacén de datos siguiendo estos pasos:
1. Inicie sesión en vCenter.
2. Navegue a su almacén de datos y haga clic en la pestaña Archivos (Files).
3. Abra la carpeta iso o cree una si no existe ninguna haciendo clic en Nueva carpeta.
4. Cargue ambos archivos ISO en la carpeta iso.

Cree un archivo YAML con el nombre builder.yaml con la siguiente configuración:

apiVersion: v1
kind: Namespace
metadata:
 name: imagebuilder
---
apiVersion: v1
kind: Service
metadata:
 name: imagebuilder-wrs
 namespace: imagebuilder
spec:
 selector:
   app: image-builder-resource-kit
 type: NodePort
 ports:
 - port: 3000
   targetPort: 3000
   nodePort: 30008
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: image-builder-resource-kit
 namespace: imagebuilder
spec:
 selector:
   matchLabels:
     app: image-builder-resource-kit
 template:
   metadata:
     labels:
       app: image-builder-resource-kit
   spec:
     nodeSelector:
       kubernetes.io/os: linux
     containers:
     - name: windows-imagebuilder-resourcekit
       image: projects.registry.vmware.com/tkg/windows-resource-bundle:v1.26.8_vmware.2-tkg.1
       imagePullPolicy: Always
       ports:
         - containerPort: 3000

La imagen de contenedor windows-resource-bundle tiene los archivos binarios de Kubernetes Windows que Image Builder necesita para compilar un archivo OVA de Windows.

Conecte la CLI de Kubernetes al clúster de administración ejecutando:
```
kubectl config use-context MY-MGMT-CLUSTER-admin@MY-MGMT-CLUSTER
```
Donde MY-MGMT-CLUSTER es el nombre del clúster de administración.
Aplique el archivo de configuración builder.yaml.
```
kubectl apply -f ./builder.yaml
```
Se implementa un contenedor que permite a la máquina recuperar los archivos que necesita de una ubicación HTTP durante el proceso de compilación de la imagen. Los resultados son similares a:
```
namespace/imagebuilder created
service/imagebuilder-wrs created
deployment.apps/image-builder-resource-kit created
```

Para asegurarse de que el contenedor se esté ejecutando, ejecute:

kubectl get pods -n imagebuilder

Los resultados son similares a:

NAME                                          READY   STATUS    RESTARTS   AGE
image-builder-resource-kit-756ccdc4ff-rcxpq   1/1     Running   0          4m16s

Recupere una dirección IP del plano de control para el clúster de administración:
1. Enumere los nodos del clúster, con los resultados wide:
```
kubectl get nodes -o wide
```
2. En los resultados, registre el valor INTERNAL-IP del nodo con ROLE como control-plane.

Cree un archivo JSON en una carpeta vacía denominada windows.json con la siguiente configuración:

{
  "additional_executables_destination_path": "C:\\ProgramData\\Temp",
  "additional_executables_list": "http://CONTROLPLANE-IP:30008/files/antrea-windows/antrea-windows-advanced.zip",
  "additional_executables": "true",
  "additional_prepull_images": "mcr.microsoft.com/windows/servercore:ltsc2019",
  "build_version": "windows-2019-kube-v1.26.8",
  "cloudbase_init_url": "http://CONTROLPLANE-IP:30008/files/cloudbase_init/CloudbaseInitSetup_1_1_4_x64.msi",
  "cluster": "VSPHERE-CLUSTER-NAME",
  "containerd_sha256_windows": "2e0332aa57ebcb6c839a8ec807780d662973a15754573630bea249760cdccf2a",
  "containerd_url": "http://CONTROLPLANE-IP:30008/files/containerd/cri-containerd-v1.6.18+vmware.1.windows-amd64.tar",
  "containerd_version": "v1.6.18",
  "convert_to_template": "true",
  "create_snapshot": "false",
  "datacenter": "DATACENTER-NAME",
  "datastore": "DATASTORE-NAME",
  "disable_hypervisor": "false",
  "disk_size": "40960",
  "goss_inspect_mode": "true",
  "insecure_connection": "true",
  "kubernetes_base_url": "http://CONTROLPLANE-IP:30008/files/kubernetes/",
  "kubernetes_semver": "v1.26.8+vmware.2",
  "kubernetes_series": "v1.26.8",
  "linked_clone": "false",
  "load_additional_components": "true",
  "netbios_host_name_compatibility": "false",
  "network": "NETWORK",
  "nssm_url": "http://CONTROLPLANE-IP:30008/files/nssm/nssm.exe",
  "os_iso_path": "OS-ISO-PATH",
  "password": "VCENTER-PASSWORD",
  "pause_image": "mcr.microsoft.com/oss/kubernetes/pause:3.6",
  "prepull": "false",
  "resource_pool": "",
  "runtime": "containerd",
  "template": "",
  "unattend_timezone": "WINDOWS-TIMEZONE",
  "username": "VCENTER-USERNAME",
  "vcenter_server": "VCENTER-IP",
  "vmtools_iso_path": "VMTOOLS-ISO-PATH",
  "windows_updates_categories": "CriticalUpdates SecurityUpdates UpdateRollups",
  "windows_updates_kbs": "",
  "wins_url": ""
}

Donde:

WINDOWS-TIMEZONE es la zona horaria Windows de su entorno. Por ejemplo, GMT Standard Time.
VSPHERE-CLUSTER-NAME es el nombre del clúster vSphere. Por ejemplo, VSAN-Cluster.
VCENTER-PASSWORD es la contraseña de vCenter.
VCENTER-USERNAME es el nombre de usuario de vCenter.
DATASTORE-NAME es el nombre del almacén de datos tal como aparece en vCenter. Por ejemplo, vsanDatastore.
DATACENTER-NAME es el nombre del centro de datos tal como aparece en vCenter. Por ejemplo, VSAN-DC.
VMTOOLS-ISO-PATH es la ruta del archivo ISO de VMware Tools estructurado de la siguiente manera: [DATASTORE-NAME] iso/VMware-tools-windows-11.2.5-17337674.iso.
NETWORK es el nombre de una red o un grupo de puertos tal como aparece en vCenter Menú > Redes > Redes (Menu > Networking > Networks). Por ejemplo, VM Network.
OS-ISO-PATH es la ruta de acceso al archivo Windows Server 2019 ISO estructurado de la siguiente manera: [DATASTORE-NAME] iso/en-us_windows_server_2019_updated_aug_2022_x64_dvd_a6431a28.iso.
VCENTER-IP es la dirección IP o el FQDN de su instancia de vCenter Server.
CONTROLPLANE-IP es la dirección IP del clúster de administración recuperada anteriormente.
CONTAINERD-URL y CONTAINERD-SHA son los valores containerd.path y containerd.sha256 recuperados anteriormente.

Consulte el paquete de recursos Windows en el endpoint nodePort del plano de control y compruebe la ruta de archivo existente:

curl http://CONTROLPLANE-IP:30008
Agregue el archivo XML que contiene la configuración de Windows siguiendo estos pasos:
1. Vaya al archivo autounattend.xml en VMware {code} Sample Exchange.
2. Seleccione Descargar.
3. Si utiliza la versión de evaluación de Windows Server 2019, elimine <ProductKey>...</ProductKey>.
4. Póngale nombre al archivo autounattend.xml
5. Guarde el archivo en la misma carpeta que el archivo windows.json.

En la carpeta que contiene el archivo windows.json y autounattend.xml, compile la imagen personalizada ejecutando:

docker run -it --rm --mount type=bind,source=$(pwd)/windows.json,target=/windows.json --mount type=bind,source=$(pwd)/autounattend.xml,target=/home/imagebuilder/packer/ova/windows/windows-2019/autounattend.xml -e PACKER_VAR_FILES="/windows.json" -e IB_OVFTOOL=1 -e IB_OVFTOOL_ARGS='--skipManifestCheck' -e PACKER_FLAGS='-force -on-error=ask' -t projects.registry.vmware.com/tkg/image-builder:v0.1.14_vmware.1 build-node-ova-vsphere-windows-2019

Si aparece un error o la compilación deja de responder, consulte los registros de Packer en la estación de trabajo para solucionar problemas en el archivo de configuración windows.json. Además, puede agregar -e PACKER_LOG=1 a la línea de comandos anterior para recibir un registro más detallado en la consola.

Para asegurarse de que la imagen de Windows esté lista para usarse, seleccione el host o el clúster en vCenter, seleccione la pestaña Máquinas virtuales (VMs) y, a continuación, seleccione Plantillas de máquina virtual (VM Templates) para ver la imagen de Windows en la lista.

Usar una imagen de Windows para un clúster de carga de trabajo

Con este procedimiento, se crea un archivo de configuración para el clúster de carga de trabajo Windows, se hace referencia a la imagen de Windows en el archivo de configuración y, a continuación, se utiliza la CLI de Tanzu para crear el clúster de carga de trabajo.

Copie el archivo de configuración del clúster de administración y guárdelo con un nombre nuevo siguiendo el procedimiento descrito en Archivos de configuración de vSphere con clúster de administración independiente.
En el nuevo archivo de configuración, agregue o modifique lo siguiente:
```
IS_WINDOWS_WORKLOAD_CLUSTER: "true"
```
Implemente un clúster de carga de trabajo como se describe en Crear clústeres de carga de trabajo.