Esta página se ha traducido con Cloud Translation API.

Crear imágenes de varios arcos de Windows Server

Estándar

En este tutorial se muestra cómo gestionar la complejidad de las versiones al crear imágenes orientadas a varias versiones de Windows Server. Los contenedores de Windows Server tienen requisitos de compatibilidad de versiones que impiden que los contenedores se ejecuten en más de una versión de host de Windows Server. Sin embargo, Docker en Windows Server admite imágenes de contenedor de varias arquitecturas (o multiplataforma) que se pueden ejecutar en varias versiones de Windows Server.

Con las imágenes de varias arquitecturas, puedes actualizar tus grupos de nodos de Windows Server de Google Kubernetes Engine (GKE) a la versión de Windows Server que prefieras sin tener que volver a crear la imagen ni cambiar las especificaciones de los pods. 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

Para actualizar automáticamente de una versión de GKE a una posterior, debes crear imágenes de varias arquitecturas para tus cargas de trabajo de Windows. Para crear una imagen de varios arcos, debes crear una imagen para cada versión de Windows Server y, a continuación, crear un manifiesto que haga referencia a esas imágenes para cada versión de Windows Server. Puedes crear las imágenes manualmente si quieres tener un control total sobre el proceso de creación y compilación de imágenes. También puedes usar Cloud Build para crear automáticamente las imágenes de varios arcos de Windows Server.

Objetivos

En este tutorial, aprenderás a crear imágenes de varios arcos de Windows Server manualmente o con Cloud Build.

Crea las imágenes manualmente:
- Crea dos imágenes de Docker con diferentes versiones o tipos de Windows Server, por ejemplo, Long-Term Servicing Channel (LTSC) y Semi-Annual Channel (SAC).
- Crea una VM de Windows Server.
- Crea un archivo de manifiesto y envíalo al registro.
Crea las imágenes con Cloud Build:
- Prepara tu entorno creando un proyecto, habilitando APIs y concediendo permisos.
- Crea una aplicación, archivos Dockerfile y archivos de compilación.
- Ejecuta un comando para compilar la imagen.

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

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

Instala Google Cloud CLI para ejecutar comandos de gcloud.
Instala Docker para crear contenedores.
Instala Go para compilar archivos binarios de Windows Server.
En este tutorial se usa Artifact Registry como repositorio. Asegúrate de haber creado tu repositorio de Docker.

Crear imágenes de varias arquitecturas manualmente

Si creas imágenes de varias arquitecturas manualmente, tendrás la flexibilidad de crear una imagen que incluya las versiones de Windows Server que necesites. Para crear una imagen de varias arquitecturas manualmente, sigue estos pasos:

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

Crea el manifiesto multiarquitectura:

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 varias arquitecturas que acabas de crear a tu repositorio de Artifact Registry:
```
 docker manifest push `
   REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0
```
Para asegurarte de que la imagen de varias arquitecturas se ha compilado y enviado correctamente, ve a REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo y haz clic en esa imagen. Verás las tres imágenes dentro:
- foo:1.0-2019
- foo:1.0-2022
- foo:1.0-20h2
- foo:1.0

Ahora puedes hacer referencia a la imagen multiarquitectura REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/foo:1.0 en tus especificaciones de Pod. De esta forma, podrás usar la actualización automática de forma segura en tus grupos de nodos de Windows de GKE.

Crear imágenes de varias arquitecturas con gke-windows-builder de Cloud Build

Para simplificar los pasos de compilación manual, puedes usar gke-windows-builder, que se basa en gke-windows-builder de OSS. Puedes usar gke-windows-builder con Cloud Build para crear automáticamente imágenes de varios arcos de Windows Server. GKE actualiza el compilador para incluir las nuevas versiones compatibles de Windows SAC y LTSC cuando se lanzan. Otra ventaja de usar el creador es que no tienes que crear tu propia máquina virtual Windows con PowerShell para crear las imágenes. La VM de Windows se sustituye por un contenedor Docker que ejecuta los comandos por ti en Cloud Build.

Para entender cómo funciona el compilador, sigue este ejemplo para crear una imagen de arquitectura múltiple "hola mundo". Estos pasos se pueden llevar a cabo en servidores Linux o Windows.

Preparar el entorno

Para preparar tu entorno, sigue estos pasos:

Crea un directorio de espacio de trabajo en tu máquina de trabajo. Por ejemplo: ~/gke-windows-builder/hello-world.
Crea o selecciona un proyecto para este tutorial.
Asegúrate de que la facturación esté habilitada en el proyecto.
Habilita las APIs Compute Engine, Cloud Build y Artifact Registry en tu proyecto. Se invoca gke-windows-builder mediante Cloud Build y las imágenes de contenedor de varias arquitecturas resultantes se insertan en Artifact Registry. Compute Engine es necesario para que el compilador cree y gestione máquinas virtuales de Windows Server.
```
gcloud services enable compute.googleapis.com cloudbuild.googleapis.com \
  artifactregistry.googleapis.com cloudbuild.googleapis.com
```

Concede los siguientes roles de Gestión de Identidades y Accesos (IAM) a tu cuenta de servicio de Cloud Build mediante la CLI de Google Cloud:

Definir variables:

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

Asigna roles. Estos roles son necesarios para que el compilador cree las VMs de Windows Server, copie el espacio de trabajo en un segmento de Cloud Storage, configure las redes para compilar la imagen de Docker y transfiera 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'

Añade una regla de cortafuegos llamada allow-winrm-ingress para permitir que WinRM se conecte a las VMs de Windows Server y ejecute una compilación de Docker:

Nota: El nombre de la regla de cortafuegos debe ser allow-winrm-ingress, ya que gke-windows-builder usa este nombre concreto para comprobar si existe esta regla de cortafuegos.
```
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 has usado repositorios de Docker en Artifact Registry, primero debes completar la guía de inicio rápido de Docker. Ejecuta este comando para crear el repositorio:
```
gcloud artifacts repositories create REPOSITORY \
  --repository-format=docker --location=REGISTRY_REGION \
  --description="Docker repository"
```
Haz los cambios siguientes:
- REPOSITORY: un nombre como windows-multi-arch-images.
- REGISTRY_REGION: una ubicación de Artifact Registry válida.

Crear el archivo binario hello.exe en tu espacio de trabajo

En este tutorial, crearás una aplicación sencilla que muestre el mensaje "Hola, mundo" escrita en Go. El código de la aplicación de ejemplo está en GitHub.

Clona el repositorio que contiene el código de ejemplo de este tutorial en tu máquina local con 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":

package main

import "fmt"

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

Genera el archivo binario hello.exe:
```
GOOS=windows go build hello.go
```

Verás el archivo binario hello.exe en tu espacio de trabajo.

Crear un Dockerfile y archivos de compilación en tu espacio de trabajo

En esta sección, usarás un Dockerfile para compilar cada imagen de Windows Server de una sola arquitectura y, a continuación, usarás un archivo de compilación para activar Cloud Build. La compilación combina las imágenes de una sola arquitectura en una imagen de varias arquitecturas.

El Dockerfile es un documento de texto que contiene instrucciones para que Docker cree una imagen. gke-windows-builder sustituye 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.
```
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 Dockerfile, el archivo cloudbuild.yaml es el archivo de configuración de compilación. Sustituye <REPOSITORY> y <REGISTRY_REGION> por el nombre y la región del repositorio de Artifact Registry que has creado en el paso anterior. En tiempo de compilación, Cloud Build sustituye automáticamente $PROJECT_ID por el ID de tu proyecto.

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'

Crear la imagen

Ahora puedes compilar la imagen y ver los registros para verificar que la compilación se ha realizado correctamente.

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

Verás registros como el siguiente ejemplo. La última línea del registro muestra que la compilación se ha realizado correctamente:

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 con el archivo de configuración de compilación y la has enviado a Artifact Registry en REGISTRY_REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/multiarch-helloworld:latest.

Desplegar la imagen

Para desplegar la imagen de Windows de varias arquitecturas en un clúster, consulta Desplegar una aplicación de Windows Server para saber cómo desplegar la imagen.

Uso avanzado de gke-windows-builder

Puedes personalizar el comportamiento de gke-windows-builder añadiendo marcas a la sección args del archivo de configuración de compilación cloudbuild.yaml. En esta sección se describen algunas marcas de comportamientos comunes, pero no se trata de una lista exhaustiva. Para ver la lista completa de marcas que admite 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

Para acelerar las 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 compatibles con GKE, puedes elegir versiones específicas de Windows Server para compilarla mediante la marca --versions:

  - --versions
  - '20H2,ltsc2019'

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

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

Para ejecutar las instancias de compilación 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'

Limpieza

Cuando hayas terminado el tutorial, puedes eliminar los recursos que has creado para que dejen de usar cuota y generar cargos. En las siguientes secciones se explica cómo eliminar o desactivar dichos recursos.

Eliminar la imagen

Para eliminar las imágenes de multiarch-helloworld en Artifact Registry, consulta Eliminar imágenes.

Eliminar el proyecto

La forma más fácil de evitar que te cobren es eliminar el proyecto que has creado para el tutorial.

Para ello, sigue las instrucciones que aparecen a continuación:

Precaución: Eliminar un proyecto tiene los siguientes efectos:

Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

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.

Siguientes pasos

Consulta otros tutoriales de Kubernetes Engine.
Consulta arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Centro de arquitectura de Cloud.