Compila imágenes de varios arcos de Windows Server

Estándar

En este instructivo, se muestra cómo administrar la complejidad del control de versiones para compilar imágenes que se orientan a varias versiones de Windows Server. Los contenedores de Windows Server tienen requisitos de compatibilidad de versiones que evitan que los contenedores se ejecuten en más de una versión del host de Windows Server. Sin embargo, Docker en Windows Server admite imágenes de contenedores de múltiples arcos (o multiplataforma) que se pueden ejecutar en varias versiones de Windows Server.

Con imágenes de múltiples arcos, puedes actualizar tus grupos de nodos de Windows Server en Google Kubernetes Engine (GKE) a tu versión de Windows Server preferida sin tener que volver a compilar la imagen y cambiar las especificaciones del pod. Por ejemplo:

La versión 1.15 de GKE es compatible con Windows Server 1809
.
La versión 1.16 de GKE es compatible con Windows Server 1909
.

Si deseas actualizar de una versión de GKE a una versión posterior automáticamente, debes compilar imágenes de varios arcos para tus cargas de trabajo de Windows. La compilación de una imagen de varios arcos implica compilar una imagen para cada versión de Windows Server y, luego, compilar un manifiesto que haga referencia a esas imágenes para cada versión de Windows Server. Puedes compilar las imágenes manualmente si deseas tener un control total sobre el proceso de compilación y creación de imágenes. Como alternativa, puedes usar Cloud Build para compilar de forma automática las imágenes de varios arcos de Windows Server.

Objetivos

En este instructivo, aprenderás a crear imágenes de varios arcos de Windows Server de forma manual o mediante Cloud Build.

Compila las imágenes de forma manual:
- Crea 2 imágenes de Docker con diferentes versiones o tipos de Windows Server, por ejemplo, el canal de servicio a largo plazo (LTSC) y el canal semianual (SAC).
- Crea una VM de Windows Server.
- Crea un manifiesto y envíalo al registro.
Compila las imágenes mediante Cloud Build:
- Prepara tu entorno mediante la creación de un proyecto, la habilitación de las API y la asignación de permisos.
- Crea una aplicación, Dockerfiles y archivos de compilación.
- Ejecuta un comando para compilar la imagen.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Instala Google Cloud CLI para ejecutar los comandos de gcloud.
Instala Docker para compilar contenedores.
Instala Go para compilar objetos binarios de Windows Server.
En este instructivo, se usa Artifact Registry como el repositorio. Asegúrate de haber creado tu repositorio de Docker.

Compila imágenes de varios arcos de forma manual

La compilación manual de imágenes de varios arcos te brinda la flexibilidad de compilar una imagen que incluya todas las versiones de Windows Server que necesites. Para compilar una imagen de varios arcos de forma manual, haz lo siguiente:

Crea una imagen de un solo arco de Docker de LTSC 2019. Consulta los detalles sobre cómo crear imágenes de Docker en Implementa una aplicación de Windows Server. Por ejemplo, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2019.
Crea una imagen de un solo arco de Docker de LTSC 2022. Por ejemplo, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-2022
Crea una imagen de un solo arco de Docker de SAC 20H2. Por ejemplo, us-docker.pkg.dev/my-project/docker-repo/foo:1.0-20h2.
Crea una VM de Windows Server, por ejemplo, versión 20H2. Consulta la Guía de inicio rápido sobre cómo usar una VM de Windows Server.
Usa RDP para conectarte a la VM.
Abre una ventana de PowerShell para ejecutar los comandos de los siguientes pasos.
Habilita la función experimental docker manifest. Un manifiesto de Docker es una lista de imágenes para enviar a un registro:
```
PS C:\> $env:DOCKER_CLI_EXPERIMENTAL = 'enabled'
```

Crea el manifiesto de varios arcos:

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

Envía el manifiesto de imagen de varios arcos recién creado a tu repositorio de Artifact Registry:
```
 docker manifest push `
   REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0
```
Para asegurarte de que tu imagen de varios arcos se haya compilado y enviado correctamente, navega hasta REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo y haz clic en esa imagen. Verás las 3 imágenes en su interior:
- foo:1.0-2019
- foo:1.0-2022
- foo:1.0-20h2
- foo:1.0

Ahora puedes hacer referencia a la imagen de varios arcos REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0 en las especificaciones de tu Pod. Esto te permitirá usar la actualización automática de forma segura para tus grupos de nodos de Windows de GKE.

Compila imágenes de varios arcos mediante gke-windows-builder de Cloud Build

Para facilitar el esfuerzo de realizar los pasos de la compilación manual, puedes usar gke-windows-builder basado en OSS gke-windows-builder. Puedes usar el gke-windows-builder con Cloud Build para compilar automáticamente las imágenes de varios arcos de Windows Server. GKE actualiza el compilador para incluir las versiones compatibles nuevas del SAC y LTSC de Windows cuando se lanzan. Otro beneficio de usar el compilador es que no tienes que crear tu propia VM de Windows mediante PowerShell para compilar las imágenes. La VM de Windows se reemplaza por un contenedor de Docker que ejecuta los comandos por ti dentro de Cloud Build.

A fin de ayudarte a comprender cómo funciona el compilador, sigue este ejemplo para compilar la imagen de varios arcos de “Hello World”. Estos pasos se pueden realizar en servidores de Linux o Windows.

Prepara el entorno

Para preparar tu entorno, completa los siguientes pasos:

Crea un directorio de lugar de trabajo en tu máquina de trabajo, por ejemplo: ~/gke-windows-builder/hello-world.
Crea o selecciona un proyecto para este instructivo.
Asegúrate de tener habilitada la facturación para tu proyecto.
Habilita las API de Compute Engine, Cloud Build y Artifact Registry para tu proyecto. El gke-windows-builder se invoca mediante Cloud Build, y las imágenes del contenedor de varios arcos resultantes se envían a Artifact Registry. Compute Engine es necesario para que el compilador cree y administre VM de Windows Server.
```
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com \
  artifactregistry.googleapis.com cloudbuild.googleapis.com
```

Otorga los siguientes roles de Identity and Access Management (IAM) a tu cuenta de servicio de Cloud Build mediante Google Cloud CLI:

Configura variables:

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

Asignar funciones. Las funciones son necesarias para que el compilador cree las VM de Windows Server, copie el lugar de trabajo en un bucket de Cloud Storage, configure las redes para compilar la imagen de Docker y envía la imagen resultante a 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'

Agrega una regla de firewall llamada allow-winrm-ingress a fin de permitir que WinRM se conecte a las VM de Windows Server para ejecutar una compilación de Docker:

Nota: El nombre de la regla de firewall debe ser allow-winrm-ingress, ya que gke-windows-builder usa este nombre en particular para verificar si existe esta regla de firewall.
```
gcloud compute firewall-rules create allow-winrm-ingress --allow=tcp:5986 --direction=INGRESS
```
Crea un repositorio de Docker en Artifact Registry para tu proyecto. Si nunca usaste repositorios de Docker en Artifact Registry, primero completa la guía de inicio rápido para Docker. Ejecuta este comando para crear tu repositorio:
```
gcloud artifacts repositories create REPOSITORY \
  --repository-format=docker --location=REGISTRY_REGION \
  --description="Docker repository"
```
Reemplaza lo siguiente:
- REPOSITORY: Un nombre como windows-multi-arch-images.
- REGISTRY_REGION: Una ubicación de Artifact Registry válida.

Crea el objeto binario hello.exe en tu lugar de trabajo

En este instructivo, crea una aplicación simple de “Hello World” escrita en Go. El código de la app de muestra se encuentra en GitHub.

Clona el repositorio que contiene el código de muestra para este instructivo en tu máquina local mediante los siguientes comandos:

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

El archivo hello.go imprime las palabras “Hello World”:

windows/windows-multi-arch/hello.go

Ver en GitHub
```
package main

import "fmt"

func main() {
	fmt.Println("Hello World!")
}
```
Genera el objeto binario hello.exe:
```
GOOS=windows go build hello.go
```

Verás el objeto binario hello.exe en tu lugar de trabajo.

Crea un Dockerfile y archivos de compilación en tu lugar de trabajo

En esta sección, debes usar un Dockerfile para compilar cada imagen de de un solo arco de Windows Server y, luego, usar un archivo de compilación a fin de activar Cloud Build. La compilación combina las imágenes de un solo arco en una imagen de varios arcos.

Un Dockerfile es un documento de texto que contiene instrucciones para que Docker compile una imagen. El gke-windows-builder reemplaza el WINDOWS_VERSION por una versión específica de Windows Server para compilar la imagen. Por ejemplo, el compilador ejecutará docker build -t multi-arch-helloworld:latest_20h2 --build-arg WINDOWS_VERSION=20H2 . en Windows Server 20H2.

windows/windows-multi-arch/Dockerfile

Ver en GitHub
```
ARG WINDOWS_VERSION=
FROM mcr.microsoft.com/windows/servercore:${WINDOWS_VERSION}
COPY hello.exe /hello.exe
USER ContainerUser
ENTRYPOINT ["hello.exe"]
```
En el mismo directorio que contiene el Dockerfile, el archivo cloudbuild.yaml es el archivo de configuración de compilación. Reemplaza <REPOSITORY> y <REGISTRY_REGION> por el nombre y la región del repositorio de Artifact Registry que creaste en el paso anterior. En el momento de la compilación, el reemplazo automático de $PROJECT_ID por tu ID del proyecto se realiza a través de Cloud Build

windows/windows-multi-arch/cloudbuild.yaml

Ver en GitHub
```
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'
```

Compila la imagen

Ahora puedes compilar la imagen y ver tus registros para verificar que se haya realizado una compilación exitosa.

Para compilar la imagen, ejecuta el siguiente comando:
```
gcloud builds submit --config=cloudbuild.yaml .
```
Nota: Este comando tarda varios minutos en ejecutarse.

Verás registros como el del siguiente ejemplo. La última línea del registro muestra que la compilación se realizó de forma exitosa:

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

Acabas de compilar la imagen mediante el archivo de configuración de compilación y la enviaste a Container Registry en REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/multiarch-helloworld:latest.

Implementa la imagen

Si quieres implementar la imagen de Windows de varios arcos en un clúster, consulta Implementa una aplicación de Windows Server para aprender a implementar la imagen.

Uso avanzado de gke-windows-builder

Para personalizar el comportamiento del gke-windows-builder, agrega marcas a la sección args del archivo de configuración de compilación cloudbuild.yaml. Algunas marcas para comportamientos comunes se describen en esta sección, pero esta no es una lista exhaustiva. Para ver la lista completa de marcas compatibles con gke-windows-builder, ejecuta el siguiente comando en un servidor Linux o en Cloud Shell:

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

A fin de acelerar tus compilaciones, puedes usar un tipo de máquina más grande para las instancias de Windows:

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

En lugar de compilar la imagen para todas las versiones de Windows que admite GKE, puedes elegir versiones específicas de Windows Server a fin de compilar mediante la marca --versions:

  - --versions
  - '20H2,ltsc2019'

Si tu lugar de trabajo tiene muchos archivos, la compilación de tu imagen será más confiable si configuras el compilador para que copie el espacio de trabajo a través de Cloud Storage en lugar de WinRM. Crea un bucket en tu proyecto, como gs://{your project}_builder y, luego, establece la marca --workspace-bucket:

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

Para ejecutar las instancias del compilador de Windows en un proyecto de servicio de VPC compartida, usa estas marcas que controlan la configuración de red de la instancia:

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

Limpia

Una vez que completes el instructivo, puedes limpiar los recursos que creaste para que dejen de usar la cuota y generar cargos. En las siguientes secciones, se describe cómo borrar o desactivar estos recursos.

Borra la imagen

Para borrar las imágenes multiarch-helloworld en Artifact Registry, consulta Borra imágenes.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

Explora otros instructivos de Kubernetes Engine.
Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.