Images de machine personnalisées Windows

Cette rubrique décrit comment créer une image de machine personnalisée Windows que Tanzu Kubernetes Grid (TKG) peut utiliser pour créer et gérer des clusters de charge de travail qui exécutent des charges de travail Windows sur des nœuds worker Windows.

Si vous créez une application basée sur des composants Windows hérités (tels que .NET Framework) et que vous souhaitez déployer des conteneurs Windows sur vSphere, suivez cette procédure pour créer une image de machine personnalisée Windows. Elle est divisée dans les sections suivantes :

Conditions préalables à l'image Windows répertorie l'environnement et les fichiers dont vous avez besoin pour créer et utiliser une image Windows.
Créer une image Windows indique comment utiliser Kubernetes Image Builder et Docker pour personnaliser et créer une image Windows.
Utiliser une image Windows pour un cluster de charge de travail indique comment déployer un cluster de charge de travail qui utilise votre image Windows comme modèle.

Remarque
VMware ne prend pas en charge les clusters de charge de travail TKG avec des nœuds worker Windows dans des environnements en proxy ou isolés.

Conditions préalables à l'image Windows

Pour créer une image de machine personnalisée, vous avez besoin des éléments suivants :

vSphere 7 ou version ultérieure.
Un poste de travail Linux.

Remarque
En raison d'un problème avec l'utilitaire packer open source utilisé par Kubernetes Image Builder, vous ne pouvez pas créer une image de machine Windows sur une machine MacOS.
Docker Desktop. Pour effectuer l'installation, reportez-vous à la page de téléchargement du produit Docker. Utilisez apt plutôt que snap pour installer Docker à partir d'une CLI.
La CLI Tanzu. Pour procéder à l'installation, reportez-vous à la section Installer la CLI Tanzu du document Installer la CLI Tanzu et la CLI Kubernetes à utiliser avec des clusters de gestion autonomes.
Cluster de gestion autonome TKG v2.3.
- Créez un cluster de gestion en suivant la procédure décrite dans Déployer des clusters de gestion avec l'interface du programme d'installation.
Une image ISO récente (plus récente qu'avril 2021) de Windows Server 2019. Téléchargez via votre compte Microsoft Developer Network (MSDN) ou de licences en volume (VL). L'utilisation d'un support d'évaluation n'est pas prise en charge ni recommandée.
La dernière image ISO Windows de VMware Tools. Téléchargez-la depuis VMware Tools.
Une banque de données sur votre instance de vCenter pouvant contenir votre modèle de machine virtuelle Windows personnalisé, avec une taille de départ supérieure à 10 Go (provisionnement dynamique).

Créer une image Windows

Importez l'image OVA Ubuntu ou Photon dans vCenter afin de l'utiliser comme modèle pour votre image personnalisée en procédant comme suit :
1. Accédez à VMware Customer Connect et connectez-vous avec les informations d'identification de VMware Customer Connect.
2. Accédez à Téléchargements de produits Tanzu Kubernetes Grid v2.3.1 (Tanzu Kubernetes Grid v2.3.1 Product Downloads).
3. Faites défiler la page jusqu'à la section intitulée Fichiers OVA Kubernetes pour VMware Tanzu Kubernetes Grid 2.3 (Kubernetes OVAs for VMware Tanzu Kubernetes Grid 2.3), recherchez Fichier OVA Ubuntu 2004 Kubernetes v1.26.8 (Ubuntu 2004 Kubernetes v1.26.8 OVA), ou Fichier OVA Photon v3 Kubernetes v1.26.8 (Photon v3 Kubernetes v1.26.8 OVA), puis cliquez sur Télécharger maintenant (Download Now).
4. Connectez-vous à vCenter.
5. Cliquez avec le bouton droit sur votre hôte ou cluster et cliquez sur Déployer le modèle OVF (Deploy OVF Template)… pour importer l'image.
6. Cliquez avec le bouton droit sur l'image importée, placez le pointeur de la souris sur Modèle (Template), puis cliquez sur Convertir en modèles (Convert to Template).
7. Pour vous assurer que le modèle est prêt à être utilisé, sélectionnez votre hôte ou votre cluster, sélectionnez l'onglet Machines virtuelles (VMs), puis sélectionnez Modèles de machine virtuelle (VM Templates) pour voir le modèle répertorié.
Importez les images ISO Windows Server 2019 et VMware Tools dans votre banque de données en procédant comme suit :
1. Connectez-vous à vCenter.
2. Accédez à votre banque de données et cliquez sur l'onglet Fichiers (Files).
3. Ouvrez le dossier iso ou créez-en un s'il n'existe pas en cliquant sur Nouveau dossier (New Folder).
4. Téléchargez les deux fichiers ISO dans le dossier iso.

Créez un fichier YAML nommé builder.yaml avec la configuration suivante :

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

L'image de conteneur windows-resource-bundle dispose des fichiers binaires kubernetes Windows dont Image Builder a besoin pour créer un fichier OVA Windows.

Connectez la CLI Kubernetes à votre cluster de gestion en exécutant :
```
kubectl config use-context MY-MGMT-CLUSTER-admin@MY-MGMT-CLUSTER
```
Où MY-MGMT-CLUSTER est le nom de votre cluster de gestion.
Appliquez le fichier de configuration builder.yaml.
```
kubectl apply -f ./builder.yaml
```
Cela déploie un conteneur qui permet à votre machine de récupérer les fichiers dont elle a besoin à partir d'un emplacement HTTP pendant le processus de création d'image. Le résultat est semblable à ce qui suit :
```
namespace/imagebuilder created
service/imagebuilder-wrs created
deployment.apps/image-builder-resource-kit created
```

Pour vous assurer que le conteneur est en cours d'exécution, exécutez :

kubectl get pods -n imagebuilder

Le résultat est semblable à ce qui suit :

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

Récupérez une adresse IP de plan de contrôle pour le cluster de gestion :
1. Répertoriez les nœuds du cluster, avec la sortie wide :
```
kubectl get nodes -o wide
```
2. À partir de la sortie, enregistrez la valeur INTERNAL-IP du nœud avec un ROLE répertorié comme control-plane.

Créez un fichier JSON dans un dossier vide nommé windows.json avec la configuration suivante :

{
  "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": ""
}

Où :

WINDOWS-TIMEZONE est le fuseau horaire Windows de votre environnement. Par exemple, GMT Standard Time.
VSPHERE-CLUSTER-NAME est le nom de votre cluster vSphere. Par exemple, VSAN-Cluster.
VCENTER-PASSWORD est votre mot de passe vCenter.
VCENTER-USERNAME est votre nom d'utilisateur vCenter.
DATASTORE-NAME est le nom de votre banque de données tel qu'il s'affiche dans vCenter. Par exemple, vsanDatastore.
DATACENTER-NAME est le nom de votre centre de données tel qu'il s'affiche dans vCenter. Par exemple, VSAN-DC.
VMTOOLS-ISO-PATH est le chemin d'accès au fichier ISO VMware Tools structuré comme suit : [DATASTORE-NAME] iso/VMware-tools-windows-11.2.5-17337674.iso.
NETWORK est le nom d'un réseau ou d'un groupe de ports tel qu'il apparaît dans Menu > Mise en réseau > Réseaux dans vCenter. Par exemple, VM Network.
OS-ISO-PATH est le chemin d'accès au fichier ISO Windows Server 2019 structuré comme suit : [DATASTORE-NAME] iso/en-us_windows_server_2019_updated_aug_2022_x64_dvd_a6431a28.iso.
VCENTER-IP est l'adresse IP ou le nom de domaine complet de votre instance de vCenter Server.
CONTROLPLANE-IP est l'adresse IP du cluster de gestion récupérée ci-dessus.
CONTAINERD-URL et CONTAINERD-SHA sont les valeurs containerd.path et containerd.sha256 récupérées ci-dessus.

Interrogez le bundle de ressources Windows sur le point de terminaison nodePort du plan de contrôle et vérifiez le chemin d'accès au fichier existant :

curl http://CONTROLPLANE-IP:30008
Ajoutez le fichier XML qui contient les paramètres Windows en procédant comme suit :
1. Accédez au fichier autounattend.xml sur Échantillon d'échange VMware {code}.
2. Sélectionnez Télécharger (Download).
3. Si vous utilisez la version d'évaluation de Windows Server 2019, supprimez <ProductKey>...</ProductKey>.
4. Nommez le fichier autounattend.xml.
5. Enregistrez le fichier dans le même dossier que le fichier windows.json.
À partir du dossier contenant vos fichiers windows.json et autounattend.xml, créez l'image personnalisée en exécutant :
```
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 vous voyez une erreur ou si la build se bloque, reportez-vous aux journaux Packer sur votre poste de travail pour résoudre les problèmes dans le fichier de configuration windows.json. En outre, vous pouvez ajouter -e PACKER_LOG=1 à la ligne de commande ci-dessus pour recevoir une journalisation plus détaillée sur votre console.
Pour vous assurer que l'image Windows est prête à être utilisée, sélectionnez votre hôte ou votre cluster dans vCenter, sélectionnez l'onglet Machines virtuelles (VMs), puis sélectionnez Modèles de machine virtuelle (VM Templates) pour voir l'image Windows répertoriée.

Utiliser une image Windows pour un cluster de charge de travail

Avec cette procédure, vous créez un fichier de configuration pour votre cluster de charge de travail Windows, vous référencez l'image Windows dans le fichier de configuration, puis vous utilisez la CLI Tanzu pour créer le cluster de charge de travail.

Copiez le fichier de configuration du cluster de gestion et enregistrez-le avec un nouveau nom en suivant la procédure décrite dans la section Fichiers de configuration de vSphere avec un cluster de gestion autonome.
Dans le nouveau fichier de configuration, ajoutez ou modifiez les éléments suivants :
```
IS_WINDOWS_WORKLOAD_CLUSTER: "true"
```
Déployez un cluster de charge de travail comme décrit dans la section Créer des clusters de charge de travail.