Images de machine personnalisées 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 :

Remarque

Les clusters de charge de travail Windows s'exécutant sur Tanzu Kubernetes Grid v1.6 ne peuvent pas être mis à niveau vers la version v2.1. Pour obtenir une solution, reportez-vous au document Notes de mise à jour de TKG v2.1.

Conditions préalables à l'image Windows

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

  • vSphere 6.7 Update 3 ou version ultérieure.
  • Un poste de travail Linux.
  • 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 Télécharger et décompresser la CLI Tanzu et kubectl dans Installer la CLI Tanzu et d'autres outils à utiliser avec des clusters de gestion autonomes.
  • Un cluster de gestion autonome TKG v2.1.
  • 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

  1. 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 à https://customerconnect.vmware.com et connectez-vous avec les informations d'identification de VMware Customer Connect.
    2. Accédez à la page de téléchargements de Tanzu Kubernetes Grid.
    3. Dans la ligne VMware Tanzu Kubernetes Grid, cliquez sur Accéder aux téléchargements (Go to Downloads).
    4. Dans le menu déroulant Sélectionner la version (Select Version), sélectionnez 2.1.
    5. Sous Téléchargements de produits (Product Downloads), faites défiler la page jusqu'à la section intitulée Images OVA Kubernetes pour VMware Tanzu Kubernetes Grid 2.1 (Kubernetes OVAs for VMware Tanzu Kubernetes Grid 2.1), recherchez l'image OVA Ubuntu 2004 Kubernetes 1.24.10 (Ubuntu 2004 Kubernetes v1.24.10 OVA), ou l'image OVA Photon 3 Kubernetes 1.24.10 (Photon v3 Kubernetes v1.24.10 OVA) puis cliquez sur Télécharger maintenant (Download Now).
    6. Connectez-vous à vCenter.
    7. 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.
    8. 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).
    9. 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é.

  2. 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.

  3. 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.24.10_vmware.1-tkg.2
       imagePullPolicy: Always
       ports:
         - containerPort: 3000

  4. 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.

  5. 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

  6. 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

  7. 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.

  8. 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,http://CONTROLPLANE-IP:30008/files/kubernetes/kube-proxy.exe",
  "additional_executables": "true",
  "additional_prepull_images": "mcr.microsoft.com/windows/servercore:ltsc2019",
  "build_version": "windows-2019-kube-v1.24.10",
  "cloudbase_init_url": "http://CONTROLPLANE-IP:30008/files/cloudbase_init/CloudbaseInitSetup_1_1_4_x64.msi",
  "cluster": "VSPHERE-CLUSTER-NAME",
  "containerd_sha256_windows": "d29f5276584e869a5933db668fd6f17b7417c48ac04dd1c2a2c7f412f948f89c",
  "containerd_url": "http://CONTROLPLANE-IP:30008/files/containerd/cri-containerd-v1.6.6+vmware.3.windows-amd64.tar",
  "containerd_version": "v1.6.6",
  "convert_to_template": "true",
  "create_snapshot": "false",
  "datacenter": "DATACENTER-NAME",
  "datastore": "DATASTORE-NAME",
  "disable_hypervisor": "false",
  "disk_size": "40960",
  "goss_inspect_mode": "true",
  "goss_url": "http://CONTROLPLANE-IP:30008/files/goss/goss-alpha-windows-amd64.exe",
  "insecure_connection": "true",
  "kubernetes_base_url": "http://CONTROLPLANE-IP:30008/files/kubernetes/",
  "kubernetes_semver": "v1.24.10+vmware.1",
  "kubernetes_series": "v1.24.10",
  "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": "http://CONTROLPLANE-IP:30008/files/wins/wins.exe",
  "wins_version": "v0.4.11"
}

    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.

  9. 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

  10. 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.

  11. À 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.13_vmware.2 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.

  12. 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.

  1. 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.

  2. Dans le nouveau fichier de configuration, ajoutez ou modifiez les éléments suivants :

    IS_WINDOWS_WORKLOAD_CLUSTER: "true"

  3. Déployez un cluster de charge de travail comme décrit dans la section Créer des clusters de charge de travail.

check-circle-line exclamation-circle-line close-line
Scroll to top icon