Criar imagens multi-arquitetura do Windows Server

Padrão

Aviso: as imagens do Canal semianual (SAC) do Windows Server não são suportadas após 9 de agosto de 2022, uma vez que a Microsoft está a remover o suporte para o SAC. Para ver o potencial impacto e as instruções de migração, consulte o artigo Fim do serviço do canal semianual do Windows Server.

Este tutorial demonstra como gerir a complexidade do controlo de versões da criação de imagens que segmentam várias versões do Windows Server. Os contentores do Windows Server têm requisitos de compatibilidade de versões que impedem a execução de contentores em mais do que uma versão do anfitrião do Windows Server. No entanto, o Docker no Windows Server suporta imagens de contentores de várias arquiteturas (ou várias plataformas) que podem ser executadas em várias versões do Windows Server.

Com as imagens multiarquitetura, pode atualizar os conjuntos de nós do Windows Server do Google Kubernetes Engine (GKE) para a sua versão preferida do Windows Server sem reconstruir a imagem nem alterar as especificações do pod. Por exemplo:

• A versão 1.15 do GKE suporta o Windows Server 1809
  
• A versão 1.16 do GKE suporta o Windows Server 1909
  

Para atualizar automaticamente de uma versão do GKE para uma versão posterior, tem de criar imagens multi-arquitetura para as suas cargas de trabalho do Windows. A criação de uma imagem multi-arquitetura envolve a criação de uma imagem para cada versão do Windows Server e, em seguida, a criação de um manifesto que faça referência a essas imagens para cada versão do Windows Server. Pode criar as imagens manualmente se quiser ter controlo total sobre o processo de criação e compilação de imagens. Em alternativa, pode usar o Cloud Build para criar automaticamente as imagens multiarquitetura do Windows Server.

Objetivos

Neste tutorial, vai aprender a criar imagens multi-arquitetura do Windows Server manualmente ou através do Cloud Build.

• Crie as imagens manualmente:

  • Crie 2 imagens de Docker com diferentes versões ou tipos do Windows Server, por exemplo, Long-Term Servicing Channel (LTSC) e Semi-Annual Channel (SAC).
  • Crie uma VM do Windows Server.
  • Crie um manifesto e envie-o para o registo.

• Crie as imagens com o Cloud Build:

  • Prepare o seu ambiente criando um projeto, ativando APIs e concedendo autorizações.
  • Criar uma aplicação, Dockerfiles e ficheiros de compilação.
  • Execute um comando para criar a imagem.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• Compute Engine
• Artifact Registry
• Cloud Build

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

1. Instale a CLI Google Cloud para executar comandos gcloud.
2. Instale o Docker para criar contentores.
3. Instale o Go para criar ficheiros binários do Windows Server.
4. Este tutorial usa o Artifact Registry como repositório. Certifique-se de que criou o seu repositório do Docker.

Nota: os comandos gcloud neste tutorial pressupõem que está a usar uma máquina Linux.

Criar imagens multi-arquitetura manualmente

Aviso: as instruções nesta secção usam uma funcionalidade experimental no Docker, que não deve ser usada em ambientes de produção. Considere as implicações da ativação desta funcionalidade nos seus sistemas.

A criação manual de imagens multi-arquitetura oferece-lhe a flexibilidade de criar uma imagem que inclua todas as versões do Windows Server de que precisa. Para criar uma imagem multi-arquitetura manualmente:

1. Crie uma imagem de arquitetura única do Docker do LTSC 2019. Veja detalhes sobre a criação de imagens do Docker em Implementar uma aplicação do Windows Server. Por exemplo, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2019.
2. Crie uma imagem de arquitetura única do Docker do LTSC 2022. Por exemplo, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2022
3. Crie uma imagem de arquitetura única do Docker do SAC 20H2. Por exemplo, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-20h2.
4. Crie uma VM do Windows Server, por exemplo, a versão 20H2. Consulte o guia de início rápido com uma VM do Windows Server.
5. Use o RDP para estabelecer ligação à VM.
6. Abra uma janela do PowerShell para executar os comandos nos passos seguintes.

7. Ative a funcionalidade experimental docker manifest. Um manifesto Docker é uma lista de imagens a enviar para um registo:

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

8. Crie o manifesto de várias arquiteturas:

   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. Envie o manifesto de imagem de várias arquiteturas recém-criado para o repositório do Artifact Registry:

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

10. Para garantir que a sua imagem de várias arquiteturas foi criada e enviada com êxito, navegue para REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo e clique nessa imagem. São apresentadas as 3 imagens no interior:

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

Agora, pode consultar a imagem multiarquitetura REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0 nas especificações do pod. Isto permite-lhe usar em segurança a atualização automática para os seus conjuntos de nós do GKE Windows.

Criar imagens multi-arquitetura com o gke-windows-builder do Cloud Build

Para facilitar o esforço dos passos de criação manual, pode usar o gke-windows-builder com base no gke-windows-builder de SO. Pode usar o gke-windows-builder com o Cloud Build para criar automaticamente as imagens multi-arquitetura do Windows Server. O GKE atualiza o criador para incluir novas versões SAC e LTSC do Windows suportadas quando são lançadas. Outra vantagem de usar o criador é que não tem de criar a sua própria VM do Windows com o Powershell para criar as imagens. A VM do Windows é substituída por um contentor Docker que executa os comandos por si no Cloud Build.

Para ajudar a compreender como funciona o criador, siga este exemplo para criar uma imagem multi-arquitetura "hello world". Estes passos podem ser realizados em servidores Linux ou Windows.

Preparar o ambiente

Para preparar o seu ambiente, conclua os seguintes passos:

1. Crie um diretório do espaço de trabalho no seu computador de trabalho, por exemplo: ~/gke-windows-builder/hello-world.
2. Crie ou selecione um projeto para este tutorial.
3. Certifique-se de que a faturação está ativada para o seu projeto.

4. Ative as APIs Compute Engine, Cloud Build e Artifact Registry para o seu projeto. O gke-windows-builder é invocado através do Cloud Build, e as imagens de contentores multiarquitetura resultantes são enviadas para o Artifact Registry. O Compute Engine é necessário para o criador criar e gerir VMs do Windows Server.

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

5. Conceda as seguintes funções de gestão de identidade e de acesso (IAM) à sua conta de serviço do Cloud Build através da CLI do Google Cloud:

   1. Definir variáveis:

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

   2. Atribuir funções. Estas funções são necessárias para o criador criar as VMs do Windows Server, copiar o espaço de trabalho para um contentor do Cloud Storage, configurar as redes para criar a imagem do Docker e enviar a imagem resultante para o 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. Adicione uma regra de firewall denominada allow-winrm-ingress para permitir que o WinRM se ligue a VMs do Windows Server para executar uma compilação do Docker:

   Nota: o nome da regra de firewall tem de ser allow-winrm-ingress, uma vez que o gke-windows-builder usa este nome específico para verificar se esta regra de firewall existe.

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

7. Crie um repositório do Docker no Artifact Registry para o seu projeto. Se nunca usou repositórios Docker no Artifact Registry, conclua primeiro o início rápido do Docker. Execute este comando para criar o seu repositório:

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

   Substitua o seguinte:

   • REPOSITORY: um nome como windows-multi-arch-images.
   • REGISTRY_REGION: uma localização do Artifact Registry válida.

Criar o ficheiro binário hello.exe no seu espaço de trabalho

Para este tutorial, crie uma aplicação simples "Olá mundo", escrita em Go. O código da app de exemplo está no GitHub.

1. Clone o repositório que contém o código de exemplo para este tutorial para a sua máquina local através dos seguintes comandos:

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

2. O ficheiro hello.go imprime as palavras "Hello World":

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

3. Gere o binário hello.exe:

   GOOS=windows go build hello.go
   

Vai ver o ficheiro binário hello.exe no seu espaço de trabalho.

Criar um Dockerfile e ficheiros de compilação no seu espaço de trabalho

Nesta secção, usa um Dockerfile para criar cada imagem do Windows Server de arquitetura única e, em seguida, usa um ficheiro de compilação para acionar o Cloud Build. A compilação combina as imagens de arquitetura única numa imagem de várias arquiteturas.

1. O Dockerfile é um documento de texto que contém instruções para o Docker criar uma imagem. O gke-windows-builder substitui WINDOWS_VERSION por uma versão específica do Windows Server para criar a imagem. Por exemplo, o criador é executado no Windows Server 20H2.docker build -t multi-arch-helloworld:latest_20h2 --build-arg WINDOWS_VERSION=20H2 .

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

2. No mesmo diretório que contém o ficheiro Dockerfile, o ficheiro cloudbuild.yaml é o seu ficheiro de configuração de compilação. Substitua <REPOSITORY> e <REGISTRY_REGION> pelo nome e pela região do repositório do Artifact Registry que criou no passo anterior. No momento da compilação, o Cloud Build substitui automaticamente $PROJECT_ID pelo ID do seu projeto.

   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'

Criar a imagem

Agora, pode criar a imagem e ver os registos para validar uma criação bem-sucedida.

1. Para criar a imagem, execute o seguinte comando:

   gcloud builds submit --config=cloudbuild.yaml .
   

   Nota: este comando demora vários minutos a concluir.

2. São apresentados registos semelhantes ao exemplo seguinte. A última linha no registo mostra que a compilação foi bem-sucedida:

   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
   

Acabou de criar a imagem com o ficheiro de configuração de compilação e enviou a imagem para o Artifact Registry em REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/multiarch-helloworld:latest.

Implementar a imagem

Para implementar a imagem do Windows de várias arquiteturas num cluster, consulte o artigo Implementar uma aplicação do Windows Server para saber como implementar a imagem.

Utilização avançada do gke-windows-builder

Pode personalizar o comportamento do gke-windows-builder adicionando flags à secção args do ficheiro de configuração da compilação cloudbuild.yaml. Algumas flags para comportamentos comuns são descritas nesta secção, mas esta não é uma lista exaustiva. Para ver a lista completa de flags que o gke-windows-builder suporta, execute o seguinte comando num servidor Linux ou no Cloud Shell:

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

Para acelerar as compilações, pode usar um tipo de máquina maior para as instâncias do Windows:

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

Em vez de criar a imagem para todas as versões do Windows suportadas pelo GKE, pode escolher versões específicas do Windows Server para criar usando a flag --versions:

  - --versions
  - '20H2,ltsc2019'

Se o seu espaço de trabalho tiver muitos ficheiros, a criação de imagens é mais fiável se configurar o criador para copiar o espaço de trabalho através do Cloud Storage em vez do WinRM. Crie um contentor no seu projeto, como gs://{your project}_builder e, em seguida, defina a flag --workspace-bucket:

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

Para executar as instâncias do criador do Windows num projeto de serviço de VPC partilhada, use estas flags que controlam a configuração de rede da instância:

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

Limpar

Depois de concluir o tutorial, pode limpar os recursos que criou para que deixem de usar a quota e incorrer em custos. As secções seguintes descrevem como eliminar ou desativar estes recursos.

Eliminar a imagem

Para eliminar as imagens do multiarch-helloworld Artifact Registry, consulte o artigo Eliminar imagens.

Eliminar o projeto

A forma mais fácil de eliminar a faturação é eliminar o projeto que criou para o tutorial.

Para eliminar o projeto:

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

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.

O que se segue?

• Explore outros tutoriais do Kubernetes Engine.

• Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.