Créer des images multi-arch Windows Server

Standard

Ce tutoriel explique comment gérer la complexité de la gestion des versions pour créer des images qui ciblent plusieurs versions de Windows Server. Les conteneurs Windows Server ont des exigences de compatibilité des versions qui empêchent l'exécution des conteneurs sur plus d'une version d'hôte Windows Server. Toutefois, Docker sous Windows Server est compatible avec les images de conteneurs multi-arch (ou multiplates-formes) qui peuvent être exécutées sur plusieurs versions de Windows Server.

Avec les images multi-arch, vous pouvez mettre à niveau vos pools de nœuds Windows Server de Google Kubernetes Engine (GKE) vers votre version Windows Server préférée sans recréer l'image et modifier les spécifications du pod. Exemple :

GKE version 1.15 est compatible avec Windows Server 1809
GKE version 1.16 est compatible avec Windows Server 1909

Pour passer automatiquement d'une version GKE à une version ultérieure, vous devez créer des images multi-arch pour vos charges de travail Windows. La création d'une image multi-arch implique la création d'une image pour chaque version de Windows Server, puis la création d'un fichier manifeste faisant référence à ces images pour chaque version de Windows Server. Vous pouvez créer les images manuellement si vous souhaitez contrôler entièrement le processus de création et de génération d'images. Vous pouvez également utiliser Cloud Build pour créer automatiquement les images multi-arch Windows Server.

Objectifs

Dans ce tutoriel, vous allez apprendre à créer des images multi-arch Windows Server manuellement ou à l'aide de Cloud Build.

Créer les images manuellement :
- Créer deux images Docker avec des versions ou des types différents de Windows Server, par exemple le canal de maintenance à long terme (LTSC, Long-Term Servicing Channel) et le canal semi-annuel (SAC, Semi-Annual Channel)
- Créer une VM Windows Server
- Créer un fichier manifeste et le transférer dans le registre
Créer les images à l'aide de Cloud Build :
- Préparer l'environnement en créant un projet, en activant des API et en accordant des autorisations
- Créer une application, des Dockerfile et des fichiers
- Exécuter une commande pour créer l'image

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Installez Google Cloud CLI pour exécuter des commandes gcloud.
Installez Docker pour créer des conteneurs.
Installez Go pour créer des binaires Windows Server.
Ce tutoriel utilise Artifact Registry comme dépôt. Assurez-vous d'avoir créé votre dépôt Docker.

Créer des images multi-arch manuellement

La création manuelle d'images multi-arch vous permet de créer une image incluant toutes les versions de Windows Server dont vous avez besoin. Pour créer une image multi-arch manuellement, procédez comme suit :

Créez une image single-arch Docker LTSC 2019. Pour en savoir plus sur la création d'images Docker, consultez la page Déployer une application Windows Server. Par exemple, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2019.
Créez une image single-arch Docker LTSC 2022. Par exemple : us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2022
Créez une image single-arch Docker SAC 20H2. Par exemple, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-20h2.
Créez une VM Windows Server, par exemple la version 20H2. Consultez le guide de démarrage rapide avec une VM Windows Server.
Utilisez le protocole RDP pour vous connecter à la VM.
Ouvrez une fenêtre PowerShell pour exécuter les commandes des étapes suivantes.
Activez la fonctionnalité expérimentale docker manifest. Un fichier manifeste Docker est une liste d'images à transférer vers un registre :
```
PS C:\> $env:DOCKER_CLI_EXPERIMENTAL = 'enabled'
```

Créez le fichier manifeste multi-arch :

docker manifest create `
  REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0 `
  REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0-2019 `
  REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0-2022 `
  REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0-20h2

Transférez le fichier manifeste d'image multi-arch que vous venez de créer dans votre dépôt Artifact Registry :
```
 docker manifest push `
   REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0
```
Pour vous assurer que votre image multi-arch a été créée et transférée, accédez à REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo et cliquez sur cette image. Les trois images suivantes s'affichent :
- foo:1.0-2019
- foo:1.0-2022
- foo:1.0-20h2
- foo:1.0

Vous pouvez maintenant faire référence à l'image multi-arch REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0 dans les spécifications de votre pod. Cela vous permettra d'utiliser la mise à niveau automatique en toute sécurité pour vos pools de nœuds Windows GKE.

Créer des images multi-arch à l'aide de Cloud Build gke-windows-builder

Pour faciliter les étapes de compilation manuelle, vous pouvez utiliser gke-windows-builder, basé sur OSS gke-windows-builder. Vous pouvez utiliser gke-windows-builder avec Cloud Build pour créer automatiquement les images multi-arch Windows Server. GKE met à jour le compilateur afin d'inclure les nouvelles versions de SAC et de LTSC compatibles lorsqu'elles sont disponibles. Un autre avantage de l'utilisation du compilateur est que vous n'avez pas besoin de créer votre propre VM Windows avec Powershell pour créer les images. La VM Windows est remplacée par un conteneur Docker qui exécute les commandes à votre place dans Cloud Build.

Pour vous aider à comprendre le fonctionnement du compilateur, suivez cet exemple pour créer une image multi-arch "Hello World". Ces étapes peuvent être effectuées sur des serveurs Linux ou Windows.

Préparer l'environnement

Pour préparer votre environnement, procédez comme suit :

Créez un répertoire d'espace de travail sur votre ordinateur de travail, par exemple : ~/gke-windows-builder/hello-world.
Créez ou sélectionnez un projet pour ce tutoriel.
Assurez-vous que la facturation est activée pour votre projet.
Activez les API Compute Engine, Cloud Build et Artifact Registry pour votre projet. La commande gke-windows-builder est appelée à l'aide de Cloud Build, et les images de conteneurs multi-arch résultantes sont envoyées à Artifact Registry. Compute Engine est nécessaire au compilateur pour créer et gérer des VM Windows Server.
```
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com \
  artifactregistry.googleapis.com cloudbuild.googleapis.com
```

Attribuez les rôles IAM (Identity and Access Management) suivants à votre compte de service Cloud Build à l'aide de Google Cloud CLI :

Définissez les variables :

export PROJECT=$(gcloud info --format='value(config.project)')
export MEMBER=$(gcloud projects describe $PROJECT --format 'value(projectNumber)')@cloudbuild.gserviceaccount.com

Attribuez les rôles. Les rôles suivants sont nécessaires pour que le compilateur crée les VM Windows Server copie l'espace de travail dans un bucket Cloud Storage, configure les réseaux de manière à créer l'image Docker et transfère l'image obtenue dans Artifact Registry :

gcloud projects add-iam-policy-binding $PROJECT --member=serviceAccount:$MEMBER --role='roles/compute.instanceAdmin'
gcloud projects add-iam-policy-binding $PROJECT --member=serviceAccount:$MEMBER --role='roles/iam.serviceAccountUser'
gcloud projects add-iam-policy-binding $PROJECT --member=serviceAccount:$MEMBER --role='roles/compute.networkViewer'
gcloud projects add-iam-policy-binding $PROJECT --member=serviceAccount:$MEMBER --role='roles/storage.admin'
gcloud projects add-iam-policy-binding $PROJECT --member=serviceAccount:$MEMBER --role='roles/artifactregistry.writer'

Ajoutez une règle de pare-feu nommée allow-winrm-ingress pour permettre à WinRM de se connecter aux VM Windows Server afin d'exécuter une compilation Docker :

Remarque : Le nom de la règle de pare-feu doit être allow-winrm-ingress, car gke-windows-builder l'utilise pour vérifier si cette règle de pare-feu existe.
```
gcloud compute firewall-rules create allow-winrm-ingress --allow=tcp:5986 --direction=INGRESS
```
Créez un dépôt Docker dans Artifact Registry pour votre projet. Si vous n'avez jamais utilisé de dépôts Docker dans Artifact Registry auparavant, suivez d'abord le guide de démarrage rapide pour Docker. Exécutez la commande suivante pour créer votre dépôt :
```
gcloud artifacts repositories create REPOSITORY \
  --repository-format=docker --location=REGISTRY_REGION \
  --description="Docker repository"
```
Remplacez les éléments suivants :
- REPOSITORY : le nom du dépôt, tel que windows-multi-arch-images.
- REGISTRY_REGION : un emplacement Artifact Registry valide.

Créer le binaire hello.exe dans votre espace de travail

Pour ce tutoriel, créez une application "Hello World" simple, écrite en Go. Le code de l'exemple d'application est disponible sur GitHub.

Clonez le dépôt contenant l'exemple de code de ce tutoriel sur votre ordinateur local à l'aide des commandes suivantes :

 git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
 cd kubernetes-engine-samples/windows/windows-multi-arch

Le fichier hello.go renvoie les mots "Hello World" :

package main

import "fmt"

func main() {
	fmt.Println("Hello World!")
}

Générez le binaire hello.exe :
```
GOOS=windows go build hello.go
```

Le binaire hello.exe s'affiche dans votre espace de travail.

Créer un Dockerfile et compiler des fichiers dans votre espace de travail

Dans cette section, vous allez utiliser un fichier Dockerfile pour compiler chaque image Windows Server single-arch, puis un fichier de compilation pour déclencher Cloud Build. La compilation combine les images single-arch en une image multi-arch.

Le fichier Dockerfile est un document texte qui contient des instructions permettant à Docker de créer une image. gke-windows-builder remplace WINDOWS_VERSION par une version spécifique de Windows Server pour laquelle l'image est générée. Par exemple, le compilateur exécute docker build -t multi-arch-helloworld:latest_20h2 --build-arg WINDOWS_VERSION=20H2 . sur Windows Server 20H2.
```
ARG WINDOWS_VERSION=
FROM mcr.microsoft.com/windows/servercore:${WINDOWS_VERSION}
COPY hello.exe /hello.exe
USER ContainerUser
ENTRYPOINT ["hello.exe"]
```

Dans le répertoire contenant le fichier Dockerfile, le fichier cloudbuild.yaml est votre fichier de configuration de compilation. Remplacez <REPOSITORY> et <REGISTRY_REGION> par le nom et la région du dépôt Artifact Registry que vous avez créé à l'étape précédente. Au moment de la compilation, Cloud Build remplace automatiquement $PROJECT_ID par l'ID de votre projet.

timeout: 3600s
steps:
- name: 'us-docker.pkg.dev/gke-windows-tools/docker-repo/gke-windows-builder:latest'
  args:
  - --container-image-name
  # Replace <REGISTRY_REGION> and <REPOSITORY>.
  - '<REGISTRY_REGION>-docker.pkg.dev/$PROJECT_ID/<REPOSITORY>/multiarch-helloworld:latest'
  # Specify specific variants of images to be built. Or, remove the following 2 lines to default to all available variants.
  - --versions
  - '20H2,ltsc2019'

Compiler l'image

Vous pouvez maintenant compiler l'image et afficher vos journaux pour vérifier que la compilation s'est bien déroulée.

Pour compiler l'image, exécutez la commande suivante :
```
gcloud builds submit --config=cloudbuild.yaml .
```
Remarque : L'exécution de cette commande prend plusieurs minutes.

Des journaux semblables à l'exemple suivant s'affichent. La dernière ligne du journal indique que la compilation a réussi :

Creating temporary tarball archive of 2 file(s) totalling 492 bytes before compression.
Uploading tarball of [.] to [gs://PROJECT_ID_cloudbuild/source/1600082502.509759-b949721a922d462c94a75da9be9f1181.tgz]
Created [https://cloudbuild.googleapis.com/v1/projects/PROJECT_ID/builds/ec333452-1301-47e8-90e2-716aeb2f5650].
Logs are available at [https://console.cloud.google.com/cloud-build/builds/ec333452-1301-47e8-90e2-716aeb2f5650?project=840737568665].
------------------------ REMOTE BUILD OUTPUT---------------------------------------
...
...

Created manifest list REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/multiarch-helloworld:latest
sha256:3ecbbc9f5144f358f81f7c7f1a7e28f069c98423d59c40eaff72bf184af0be02
2020/09/14 11:34:25 Instance: 35.184.178.49 shut down successfully
PUSH
DONE
-----------------------------------------------------------------------------------

ID                                    CREATE_TIME                DURATION  SOURCE                                                                                      IMAGES  STATUS
ec333452-1301-47e8-90e2-716aeb2f5650  2020-09-14T11:21:43+00:00  12M43S    gs://PROJECT_ID_cloudbuild/source/1600082502.509759-b949721a922d462c94a75da9be9f1181.tgz  -                 SUCCESS

Vous venez de compiler l'image à l'aide du fichier de configuration de compilation et l'avez transférée vers REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/multiarch-helloworld:latest dans Artifact Registry.

Déployer l'image

Pour déployer l'image Windows multi-arch sur un cluster, consultez la page Déployer une application Windows Server pour savoir comment déployer l'image.

Utilisation avancée de gke-windows-builder

Vous pouvez personnaliser le comportement de gke-windows-builder en ajoutant des options à la section args du fichier de configuration de compilation cloudbuild.yaml. Certaines options de comportements courants sont décrits dans cette section, mais cette liste n'est pas exhaustive. Pour afficher la liste complète des options compatibles avec gke-windows-builder, exécutez la commande suivante sur un serveur Linux ou dans Cloud Shell :

docker run -it us-docker.pkg.dev/gke-windows-tools/docker-repo/gke-windows-builder:latest --help

Pour accélérer vos compilations, utilisez un type de machine avec des caractéristiques plus importantes pour les instances Windows :

  - --machineType
  - 'n1-standard-8'

Au lieu de créer l'image pour toutes les versions de Windows compatibles avec GKE, vous pouvez choisir des versions spécifiques de Windows Server à l'aide de l'option --versions :

  - --versions
  - '20H2,ltsc2019'

Si votre espace de travail contient de nombreux fichiers, la compilation de votre image sera plus fiable si vous configurez le compilateur pour copier l'espace de travail via Cloud Storage plutôt que WinRM. Créez un bucket dans votre projet, tel que gs://{your project}_builder, puis définissez l'option --workspace-bucket :

  - --workspace-bucket
  - '{your project}_builder'

Pour exécuter les instances du compilateur Windows dans un projet de service VPC partagé, utilisez les options suivantes qui contrôlent la configuration du réseau de l'instance :

  - --subnetwork-project
  - 'shared-vpc-host-project'
  - --subnetwork
  - 'host-project-subnet-shared-with-service-project'

Nettoyer

Une fois le tutoriel terminé, vous pouvez procéder au nettoyage des ressources que vous avez créées afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer l'image

Pour supprimer les images multiarch-helloworld d'Artifact Registry, consultez la section Supprimer des images.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Étape suivante

Découvrez d'autres tutoriels Kubernetes Engine.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.