Creazione di immagini multi-arch Windows Server

Standard

---

Avviso:le immagini del canale semestrale (SAC) di Windows Server non sono supportate dopo il 9 agosto 2022 perché Microsoft sta rimuovendo il supporto per il SAC. Per informazioni su potenziali impatti e istruzioni per la migrazione, consulta Fine del servizio del canale semestrale di Windows Server.

Questo tutorial mostra come gestire la complessità del controllo delle versioni della creazione di immagini destinate a più versioni di Windows Server. I container di Windows Server hanno requisiti di compatibilità delle versioni che impediscono ai container di essere eseguiti su più di una versione host di Windows Server. Tuttavia, Docker su Windows Server supporta immagini container multi-architettura (o multipiattaforma) che possono essere eseguite su più versioni di Windows Server.

Con le immagini multi-arch, puoi eseguire l'upgrade dei pool di nodi Windows Server di Google Kubernetes Engine (GKE) alla versione di Windows Server che preferisci senza ricompilare l'immagine e modificare le specifiche del pod. Ad esempio:

• GKE versione 1.15 supporta Windows Server 1809
  
• GKE versione 1.16 supporta Windows Server 1909
  

Per eseguire l'upgrade automatico da una versione di GKE a una successiva, devi creare immagini multi-architettura per i tuoi workload Windows. La creazione di un'immagine multi-arch prevede la creazione di un'immagine per ogni versione di Windows Server e poi la creazione di un manifest che faccia riferimento a queste immagini per ogni versione di Windows Server. Puoi creare le immagini manualmente se vuoi avere il controllo completo sul processo di creazione e build delle immagini. In alternativa, puoi utilizzare Cloud Build per creare automaticamente le immagini multi-arch Windows Server.

Obiettivi

In questo tutorial imparerai a creare manualmente immagini multi-arch Windows Server o utilizzando Cloud Build.

• Crea le immagini manualmente:

  • Crea due immagini Docker con versioni o tipi diversi di Windows Server, ad esempio Long-Term Servicing Channel (LTSC) e Semi-Annual Channel (SAC).
  • Crea una VM Windows Server.
  • Crea un manifest ed eseguirne il push nel registro.

• Crea le immagini utilizzando Cloud Build:

  • Prepara l'ambiente creando un progetto, abilitando le API e concedendo le autorizzazioni.
  • Crea un'applicazione, Dockerfile e file di build.
  • Esegui un comando per creare l'immagine.

Costi

In questo documento, utilizzi i seguenti componenti fatturabili di Google Cloud:

• Compute Engine
• Artifact Registry
• Cloud Build

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

1. Installa Google Cloud CLI per eseguire i comandi gcloud.
2. Installa Docker per creare container.
3. Installa Go per creare i file binari di Windows Server.
4. Questo tutorial utilizza Artifact Registry come repository. Assicurati di aver creato il repository Docker.

Nota: i comandi gcloud di questo tutorial presuppongono che tu stia utilizzando un computer Linux.

Creazione manuale di immagini multi-arch

Avviso:le istruzioni riportate in questa sezione utilizzano una funzionalità sperimentale di Docker che non deve essere utilizzata negli ambienti di produzione. Considera le implicazioni dell'attivazione di questa funzionalità sui tuoi sistemi.

La creazione manuale di immagini multi-architettura offre la flessibilità di creare un'immagine che includa le versioni di Windows Server di cui hai bisogno. Per creare manualmente un'immagine multi-architettura:

1. Crea un'immagine Docker LTSC 2019 a singola architettura. Per maggiori dettagli sulla creazione di immagini Docker, consulta Deployment di un'applicazione Windows Server. Ad esempio, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2019.
2. Crea un'immagine Docker LTSC 2022 a singola architettura. Ad esempio, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2022
3. Crea un'immagine Docker SAC 20H2 a singola architettura. Ad esempio, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-20h2.
4. Crea una VM Windows Server, ad esempio la versione 20H2. Consulta la Guida rapida all'utilizzo di una VM Windows Server.
5. Utilizza RDP per connetterti alla VM.
6. Apri una finestra di PowerShell per eseguire i comandi nei passaggi successivi.

7. Attiva la funzionalità sperimentale docker manifest. Un manifest Docker è un elenco di immagini da eseguire il push in un registro:

   PS C:\> $env:DOCKER_CLI_EXPERIMENTAL = 'enabled'
   

8. Crea il manifest 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
   

9. Esegui il push del manifest dell'immagine multi-architettura appena creato nel repository Artifact Registry:

    docker manifest push `
      REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0
   

10. Per assicurarti che l'immagine multi-architettura sia stata creata e trasferita correttamente, vai a REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo e fai clic sull'immagine. Vedrai le tre immagini all'interno:

    • foo:1.0-2019
    • foo:1.0-2022
    • foo:1.0-20h2
    • foo:1.0

Ora puoi fare riferimento all'immagine multi-architettura REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0 nelle specifiche del pod. In questo modo potrai utilizzare in sicurezza l'upgrade automatico per i tuoi pool di nodi GKE Windows.

Creazione di immagini multi-architettura utilizzando gke-windows-builder di Cloud Build

Per semplificare gli sforzi dei passaggi di compilazione manuale, puoi utilizzare gke-windows-builder basato su gke-windows-builder OSS. Puoi utilizzare gke-windows-builder con Cloud Build per creare automaticamente le immagini multi-arch Windows Server. GKE aggiorna il builder in modo da includere le nuove versioni supportate di Windows SAC e LTSC quando vengono rilasciate. Un altro vantaggio dell'utilizzo dello strumento di creazione è che non devi creare la tua VM Windows con PowerShell per creare le immagini. La VM Windows viene sostituita da un container Docker che esegue i comandi per te all'interno di Cloud Build.

Per aiutarti a capire come funziona il builder, segui questo esempio per creare un'immagine multi-architettura "hello world". Questi passaggi possono essere eseguiti su server Linux o Windows.

Preparazione dell'ambiente

Per preparare l'ambiente:

1. Crea una directory di Workspace sulla tua macchina di lavoro, ad esempio: ~/gke-windows-builder/hello-world.
2. Crea o seleziona un progetto per questo tutorial.
3. Assicurati che la fatturazione sia attivata per il tuo progetto.

4. Abilita le API Compute Engine, Cloud Build e Artifact Registry per il tuo progetto. gke-windows-builder viene richiamato utilizzando Cloud Build e le immagini container multiazione risultanti vengono inviate a Artifact Registry. Compute Engine è necessario per consentire al builder di creare e gestire le VM Windows Server.

   gcloud services enable compute.googleapis.com cloudbuild.googleapis.com \
     artifactregistry.googleapis.com cloudbuild.googleapis.com
   

5. Concedi i seguenti ruoli Identity and Access Management (IAM) al tuo account di servizio Cloud Build utilizzando la Google Cloud CLI:

   1. Imposta le variabili:

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

   2. Assegna ruoli. Questi ruoli sono necessari al builder per creare le VM Windows Server, copiare lo spazio di lavoro in un bucket Cloud Storage, configurare le reti per creare l'immagine Docker ed eseguire il push dell'immagine risultante in 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'
      

6. Aggiungi una regola firewall denominata allow-winrm-ingress per consentire a WinRM di connettersi alle VM Windows Server per eseguire una build Docker:

   Nota :il nome della regola firewall deve essere allow-winrm-ingress, in quanto gke-windows-builder utilizza questo nome specifico per verificare se questa regola firewall esiste.

   gcloud compute firewall-rules create allow-winrm-ingress --allow=tcp:5986 --direction=INGRESS
   

7. Crea un repository Docker in Artifact Registry per il tuo progetto. Se non hai mai utilizzato i repository Docker in Artifact Registry, completa prima la Guida rapida per Docker. Esegui questo comando per creare il repository:

   gcloud artifacts repositories create REPOSITORY \
     --repository-format=docker --location=REGISTRY_REGION \
     --description="Docker repository"
   

   Sostituisci quanto segue:

   • REPOSITORY: un nome come windows-multi-arch-images.
   • REGISTRY_REGION: una posizione Artifact Registry valida.

Creazione del file binario hello.exe nel tuo spazio di lavoro

Per questo tutorial, crea una semplice applicazione "Hello World" scritta in Go. Il codice dell'app di esempio è disponibile su GitHub.

1. Clona il repository contenente il codice campione per questo tutorial sulla tua macchina locale utilizzando i seguenti comandi:

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

2. Il file hello.go stampa le parole "Hello World":

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

3. Genera il binario hello.exe:

   GOOS=windows go build hello.go
   

Vedrai il binario hello.exe nel tuo spazio di lavoro.

Creazione di un Dockerfile e di file di build nello spazio di lavoro

In questa sezione utilizzi un Dockerfile per creare ogni immagine a singola architettura di Windows Server e poi utilizzi un file di build per attivare Cloud Build. La build combina le immagini a singola architettura in un'immagine multi-architettura.

1. Dockerfile è un documento di testo che contiene le istruzioni per Docker per creare un'immagine. gke-windows-builder sostituisce WINDOWS_VERSION con una versione specifica di Windows Server per creare l'immagine. Ad esempio, lo strumento di creazione eseguirà docker build -t multi-arch-helloworld:latest_20h2 --build-arg WINDOWS_VERSION=20H2 . su Windows Server 20H2.

   ARG WINDOWS_VERSION=
   FROM mcr.microsoft.com/windows/servercore:${WINDOWS_VERSION}
   COPY hello.exe /hello.exe
   USER ContainerUser
   ENTRYPOINT ["hello.exe"]

2. Nella stessa directory contenente Dockerfile, il file cloudbuild.yaml è il file di configurazione della build. Sostituisci <REPOSITORY> e <REGISTRY_REGION> con il nome e la regione del repository Artifact Registry che hai creato nel passaggio precedente. Al momento della build, Cloud Build sostituisce automaticamente $PROJECT_ID con l'ID del tuo progetto.

   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'

Creazione dell'immagine

Ora puoi creare l'immagine e visualizzare i log per verificare che la build sia stata eseguita correttamente.

1. Per creare l'immagine, esegui questo comando:

   gcloud builds submit --config=cloudbuild.yaml .
   

   Nota: il completamento di questo comando richiede diversi minuti.

2. Vedrai log simili all'esempio seguente. L'ultima riga del log mostra che la build è riuscita:

   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
   

Hai appena creato l'immagine utilizzando il file di configurazione della build e hai eseguito il push dell'immagine ad Artifact Registry all'indirizzo REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/multiarch-helloworld:latest.

Deployment dell'immagine

Per eseguire il deployment dell'immagine Windows multi-arch su un cluster, consulta Deployment di un'applicazione Windows Server per scoprire come eseguire il deployment dell'immagine.

Utilizzo avanzato di gke-windows-builder

Puoi personalizzare il comportamento di gke-windows-builder aggiungendo flag alla sezione args del file di configurazione della build cloudbuild.yaml. In questa sezione sono descritti alcuni flag per i comportamenti comuni, ma non si tratta di un elenco esaustivo. Per visualizzare l'elenco completo dei flag supportati da gke-windows-builder, esegui il seguente comando su un server Linux o in Cloud Shell:

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

Per velocizzare le build, puoi utilizzare un tipo di macchina più grande per le istanze Windows:

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

Anziché creare l'immagine per tutte le versioni di Windows supportate da GKE, puoi scegliere versioni specifiche di Windows Server per la creazione utilizzando il flag --versions:

  - --versions
  - '20H2,ltsc2019'

Se il tuo spazio di lavoro contiene molti file, la creazione dell'immagine sarà più affidabile se configuri il builder per copiare lo spazio di lavoro tramite Cloud Storage anziché WinRM. Crea un bucket nel progetto, ad esempio gs://{your project}_builder, quindi imposta il flag --workspace-bucket:

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

Per eseguire le istanze di build di Windows in un progetto di servizio VPC condiviso, utilizza questi flag che controllano la configurazione di rete dell'istanza:

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

Esegui la pulizia

Al termine del tutorial, puoi liberare spazio eliminando le risorse che hai creato in modo che non utilizzino più la quota e non generino addebiti. Le seguenti sezioni descrivono come eliminare o disattivare queste risorse.

Eliminazione dell'immagine

Per eliminare le immagini multiarch-helloworld su Artifact Registry, consulta la sezione Eliminare immagini.

Eliminazione del progetto

Il modo più semplice per eliminare la fatturazione è quello di eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini, elimini anche tutto il lavoro che hai svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi

• Esplora altri tutorial su Kubernetes Engine.

• Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.