Questa pagina è stata tradotta dall'API Cloud Translation.

Creazione di immagini multi-arch Windows Server

Standard

Questo tutorial mostra come gestire la complessità del controllo delle versioni della creazione che hanno come target più versioni di Windows Server. I container di Windows Server hanno requisiti di compatibilità delle versioni che impediscono l'esecuzione dei container su più di una versione dell'host Windows Server. Tuttavia, Docker su Windows Server supporta container multi-arch (o multipiattaforma) che possono essere eseguite su più versioni di Windows Server.

Con le immagini multi-arch puoi eseguire l'upgrade di Google Kubernetes Engine (GKE) I pool di nodi di Windows Server sul tuo Windows Server preferito senza dover ricreare 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 automaticamente l'upgrade da una versione GKE a una versione successiva, devi creare immagini multi-arch per i carichi di lavoro Windows. La creazione di un'immagine multi-arch prevede la creazione di un'immagine per ogni versione di Windows Server e poi di un manifest che fa 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 compilazione delle immagini. In alternativa, puoi utilizzare Cloud Build creano automaticamente le immagini multi-arch di Windows Server.

Obiettivi

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

Crea le immagini manualmente:
- crea 2 immagini Docker con versioni o tipi di Windows diversi Server, ad esempio LTSC (Long-Term Servicing Channel) e semestrale Canale (SAC).
- Crea una VM Windows Server.
- Creare un manifest ed eseguirne il push nel registro.
Crea le immagini con Cloud Build:
- Prepara l'ambiente creando un progetto, abilitando le API e concedere le autorizzazioni.
- Crea un'applicazione, Dockerfile e file di compilazione.
- Esegui un comando per creare l'immagine.

Costi

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

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

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

Creazione manuale di immagini multi-arch

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

Crea un'immagine ad arco singolo Docker LTSC 2019. Consulta i dettagli sulla creazione di immagini Docker in Eseguire il deployment di un'applicazione Windows Server. Ad esempio, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2019.
Crea un'immagine Docker LTSC 2022 a architettura singola. Ad esempio, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2022
Crea un'immagine Docker a architettura singola SAC 20H2. Ad esempio, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-20h2.
Crea una VM Windows Server, ad esempio la versione 20H2. Consulta la Guida rapida all'utilizzo di una VM Windows Server.
Utilizza RDP per la connessione alla VM.
Apri una finestra PowerShell per eseguire i comandi nei passaggi successivi.
Attiva la funzionalità sperimentale docker manifest. Un manifest Docker è un di immagini di cui eseguire il push a un registro:
```
PS C:\> $env:DOCKER_CLI_EXPERIMENTAL = 'enabled'
```

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

Esegui il push del manifest dell'immagine multi-arch appena creato nel tuo repository Artifact Registry:
```
 docker manifest push `
   REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0
```
Per assicurarti che l'immagine multi-architettura sia stata creata e inviata correttamente, vai a REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo e fai clic sull'immagine. Vedrai le 3 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-arch REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0 nel tuo specifiche dei pod. In questo modo potrai utilizzare in sicurezza l'upgrade automatico Pool di nodi Windows.

Creazione di immagini multi-arch utilizzando il compilatore gke-windows-builder di Cloud Build

Per semplificare i passaggi di creazione manuali, puoi utilizzare gke-windows-builder basato su gke-windows-builder. Puoi usare gke-windows-builder con Cloud Build per creare Server di immagini multi-arch automaticamente. GKE aggiorna il builder in modo da includere le nuove versioni supportate di Windows SAC e LTSC al momento del rilascio. Un altro vantaggio dell'utilizzo del generatore è 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 all'interno di Cloud Build.

Per aiutarti a capire come funziona lo strumento di creazione, segui questo esempio per creare una "ciao mondo" multi-arch. Questi passaggi possono essere eseguiti su server Linux o Windows.

Preparazione dell'ambiente

Per preparare l'ambiente, completa i seguenti passaggi:

Crea una directory di lavoro sulla tua macchina di lavoro, ad esempio: ~/gke-windows-builder/hello-world.
Crea o seleziona un progetto per questo tutorial.
Assicurati che la fatturazione sia abilitata per il progetto.
Abilita le API Compute Engine, Cloud Build e Artifact Registry per il tuo progetto. gke-windows-builder viene richiamato utilizzando Cloud Build e il push delle immagini container multi-arch risultanti viene eseguito Artifact Registry. Compute Engine è necessario affinché il builder crei e gestire le VM Windows Server.
```
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com \
  artifactregistry.googleapis.com cloudbuild.googleapis.com
```

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

Imposta le variabili:

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

Assegna i ruoli. Questi ruoli sono necessari per consentire al builder di 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'

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

Nota: il nome della regola firewall deve essere allow-winrm-ingress, poiché gke-windows-builder utilizza questo nome specifico per verificare se la regola firewall esiste.
```
gcloud compute firewall-rules create allow-winrm-ingress --allow=tcp:5986 --direction=INGRESS
```
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. Corsa 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: un valore valido per Posizione Artifact Registry.

Creazione del file binario hello.exe nello spazio di lavoro

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

Clona il repository contenente il codice campione per questo tutorial della macchina locale utilizzando i seguenti comandi:

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

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

package main

import "fmt"

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

Genera il programma binario hello.exe:
```
GOOS=windows go build hello.go
```

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

Creazione di un Dockerfile e file di build nell'area di lavoro

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

Dockerfile è un documento di testo che contiene istruzioni per consentire a Docker di creare un'immagine. gke-windows-builder sostituisce WINDOWS_VERSION con una versione specifica di Windows Server per la quale creare l'immagine. Ad esempio, il generatore 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"]
```

Nella stessa directory che contiene Dockerfile, 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. In fase di creazione volta, Cloud Build sostituisce automaticamente $PROJECT_ID con il tuo progetto ID.

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

Per creare l'immagine, esegui questo comando:
```
gcloud builds submit --config=cloudbuild.yaml .
```
Nota: il completamento di questo comando richiede diversi minuti.

Vedrai log come nell'esempio seguente. L'ultima riga del log mostra la creazione è 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 ne hai eseguito il push ad Artifact Registry all'indirizzo REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/multiarch-helloworld:latest.

Esegui il deployment dell'immagine

Per eseguire il deployment dell'immagine Windows multi-arch su un cluster, consulta Eseguire il 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. Alcuni flag per comportamenti comuni sono descritti in questa sezione, 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'

Invece di creare l'immagine per tutte le versioni Windows che GKE puoi scegliere versioni specifiche di Windows Server da utilizzare per la creazione il flag --versions:

  - --versions
  - '20H2,ltsc2019'

Se la tua area di lavoro contiene molti file, la compilazione dell'immagine sarà più affidabile se configurerai il generatore in modo che copi l'area 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 Windows Builder 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 eseguire la pulizia delle risorse che hai creato in modo smetti di usare la quota e ti vengono addebitati dei costi. Le sezioni seguenti descrivono come eliminare o disattivare queste risorse.

Eliminazione dell'immagine

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

Elimina il progetto

Il modo più semplice per eliminare la fatturazione 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 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 appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

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.

Passaggi successivi

Esplora altri tutorial su Kubernetes Engine.
Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.