Container Registry está obsoleto y se programó para el cierre. A partir del 15 de mayo de 2024, Artifact Registry aloja imágenes para el dominio gcr.io en proyectos sin uso anterior de Container Registry. Después del 18 de marzo de 2025, Container Registry estará cerrado.

Para comenzar a administrar contenedores en Google Cloud, usa Artifact Registry. Si usas Container Registry, aprende a realizar la transición a Artifact Registry para administrar tus contenedores en Google Cloud.

Para obtener más información sobre la baja y la baja, consulta la página de bajas y las notas de la versión.

Se usó la API de Cloud Translation para traducir esta página.

Migra contenedores desde un registro de terceros

Si extraes algunas imágenes de contenedor directamente de los registros de terceros para implementarlas en entornos de Google Cloud, como Google Kubernetes Engine o Cloud Run, los límites de frecuencia de las extracciones de imágenes o interrupciones de terceros pueden interrumpir tus implementaciones y compilaciones. Esta página describe cómo identificar y copiar esas imágenes en un registro en Google Cloud para obtener imágenes de contenedor coherentes y y administración de posturas.

Además, puedes aprovechar otras funciones, como la seguridad tu cadena de suministro de software con el análisis de vulnerabilidades y la aplicación de políticas de implementación con la Autorización Binaria.

Elige un registro

Artifact Registry es el servicio recomendado para almacenar y administrar imágenes de contenedor y otros artefactos de compilación en Google Cloud.

Si no usas Container Registry, migrar imágenes a Artifact Registry en su lugar. Artifact Registry proporciona mayor flexibilidad y control, lo que incluye Almacenar imágenes en una región en lugar de una multirregión, con un acceso más detallado un control de acceso basado en la nube y compatibilidad con otros formatos de artefactos.
Si usas Container Registry, puedes migrar a Artifact Registry.

Descripción general de la migración

La migración de tus imágenes de contenedor incluye los siguientes pasos:

Configura los requisitos.
Identifique las imágenes que se migrarán.
- Busca tus archivos de Dockerfile y manifiestos de implementación para obtener referencias de registros de terceros
- Determina la frecuencia de extracción de las imágenes de los registros de terceros mediante Cloud Logging y BigQuery.
Copia imágenes identificadas a Container Registry.
Verifica que los permisos del registro estén configurados correctamente, en especial si Container Registry y tu entorno de implementación de Google Cloud están en proyectos diferentes.
Actualiza los manifiestos de tus implementaciones.
Vuelve a implementar tus cargas de trabajo.
(Opcional) Bloquea implementaciones de imágenes de fuentes de terceros.

Container Registry no supervisa los registros de terceros para las actualizaciones de las imágenes que copias en Container Registry. Si deseas incorporar una versión más reciente de una imagen en tu canalización, debes enviarla a Container Registry.

Antes de comenzar

Verifica tus permisos. Debes tener la función de IAM de propietario o editor en los proyectos en los que migras imágenes a Container Registry.
Ir a la página de selección de proyecto
1. Selecciona el proyecto de Google Cloud en el que deseas usar Container Registry
2. En la consola de Google Cloud, ve a Cloud Shell
3. Busca el ID del proyecto y establécelo en Cloud Shell. Reemplaza YOUR_PROJECT_ID con el ID del proyecto.
```
gcloud config set project YOUR_PROJECT_ID
```

Exporta las siguientes variables de entorno:

  export PROJECT=$(gcloud config get-value project)

Habilita las API de BigQuery, Container Registry y Cloud Monitoring con el siguiente comando:

gcloud services enable \
containerregistry.googleapis.com \
stackdriver.googleapis.com \
logging.googleapis.com \
monitoring.googleapis.com

Verifica que esté instalada la versión 1.13 de Go o una más reciente.
- Verifica la versión de una instalación de Go existente con el siguiente comando:
```
go version
```
- Si necesitas instalar o actualizar Go, consulta la documentación de instalación de Go.

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Identifica las imágenes que se migrarán.

Busca los archivos que usas para compilar e implementa imágenes de contenedor a fin de hacer referencia a registros de terceros y, luego, verifica la frecuencia con la que extraes las imágenes.

Identifica referencias en Dockerfiles

Realiza este paso en una ubicación en la que se almacenen tus Dockerfiles. Esta ubicación puede ser donde tu código se verifica de forma local o en Cloud Shell si los archivos están disponibles en una VM.

En el directorio con tus Dockerfiles, ejecuta el siguiente comando:

grep -inr -H --include Dockerfile\* "FROM" . | grep -i -v -E 'docker.pkg.dev|gcr.io'

El resultado se ve como en el siguiente ejemplo:

./code/build/baseimage/Dockerfile:1:FROM debian:stretch
./code/build/ubuntubase/Dockerfile:1:FROM ubuntu:latest
./code/build/pythonbase/Dockerfile:1:FROM python:3.5-buster

Este comando busca en todos los Dockerfiles de tu directorio y, luego, identifica la línea "FROM". Ajusta el comando según sea necesario para que coincida con tu forma de almacenar los Dockerfiles.

Identifica referencias en manifiestos

Realiza este paso en una ubicación en la que se almacenen tus manifiestos de GKE o Cloud Run. Esta ubicación puede ser donde tu código se verifica de forma local o en Cloud Shell si los archivos están disponibles en una VM.

En el directorio con tus manifiestos de GKE o Cloud Run, ejecuta el siguiente comando:
```
grep -inr -H --include \*.yaml "image:" . | grep -i -v -E 'docker.pkg.dev|gcr.io'
```
Resultado de muestra:
```
./code/deploy/k8s/ubuntu16-04.yaml:63: image: busybox:1.31.1-uclibc
./code/deploy/k8s/master.yaml:26:      image: kubernetes/redis:v1
```
Este comando analiza todos los archivos YAML en tu directorio y, luego, identifica la línea imagen:; ajusta según sea necesario para trabajar con la manera en que se almacenan los manifiestos.
Para enumerar las imágenes que se ejecutan actualmente en un clúster, ejecuta el siguiente comando:
```
  kubectl get all --all-namespaces -o yaml | grep image: | grep -i -v -E 'docker.pkg.dev|gcr.io'
```
Este comando muestra todos los objetos que se ejecutan en el clúster de Kubernetes seleccionado actualmente y obtiene los nombres de las imágenes.

Resultado de muestra:
```
- image: nginx
  image: nginx:latest
    - image: nginx
    - image: nginx
```

Ejecuta este comando para todos los clústeres de GKE en todos los proyectos de Google Cloud a fin de obtener una cobertura total.

Identifica la frecuencia de extracción de un registro de terceros

En los proyectos que extraen registros de terceros, usa información sobre la frecuencia de extracción de imágenes para determinar si el uso se encuentra cerca o por encima de los límites de frecuencia que aplica el registro de terceros.

Recopila datos de registro

Crea un receptor de registros para exportar datos a BigQuery. Un receptor de registros posee un destino y una consulta que selecciona las entradas de registro que se exportarán. Puedes crear un receptor mediante la consulta de proyectos individuales o puedes usar una secuencia de comandos para recopilar datos entre proyectos.

A fin de crear un receptor para un solo proyecto, sigue estos pasos:

Estas instrucciones son para la interfaz de vista previa de Logging.

Ir al Explorador de registros.
Elige un proyecto de Google Cloud.
En la pestaña Compilador de consultas, ingresa la siguiente consulta:
```
  resource.type="k8s_pod"
  jsonPayload.reason="Pulling"
```
Filtro de historial de cambios de Last 1 hour hasta Últimos 7 días
Haga clic en Run Query.
Después de verificar que los resultados se muestren correctamente, haz clic en Acciones > Crear receptor.
En la lista de receptores, selecciona Conjunto de datos de BigQuery y, luego, haz clic en Siguiente.
En el panel Editar receptor, sigue estos pasos:
- En el campo Nombre del receptor, ingresa image_pull_logs.
- En el campo Destino del receptor, crea un conjunto de datos nuevo o elige un conjunto de datos de destino en otro proyecto.
Haz clic en Crear receptor.

A fin de crear un receptor para varios proyectos, haz lo siguiente:

Abre Cloud Shell.

Ejecute los siguientes comandos en Cloud Shell:

PROJECTS="PROJECT-LIST"
DESTINATION_PROJECT="DATASET-PROJECT"
DATASET="DATASET-NAME"

for source_project in $PROJECTS
do
  gcloud logging --project="${source_project}" sinks create image_pull_logs bigquery.googleapis.com/projects/${DESTINATION_PROJECT}/datasets/${DATASET} --log-filter='resource.type="k8s_pod" jsonPayload.reason="Pulling"'
done

donde

PROJECT-LIST es una lista de ID de proyectos de Google Cloud separados por espacios. Por ejemplo, project1 project2 project3.
DATASET-PROJECT es el proyecto en el que deseas almacenar tu conjunto de datos.
DATASET-NAME es el nombre del conjunto de datos, por ejemplo image_pull_logs.

Después de crear un receptor, los datos tardan en fluir hacia las tablas de BigQuery, según la frecuencia con la que se extraen las imágenes.

Consulta la frecuencia de extracción

Una vez que tengas una muestra representativa de las extracciones de imágenes que realizan tus compilaciones, ejecuta una consulta para conocer la frecuencia de extracción.

Dirígete a la consola de BigQuery

Ejecute la siguiente consulta:

SELECT
  REGEXP_EXTRACT(jsonPayload.message, r'"(.*?)"') AS imageName,
  COUNT(*) AS numberOfPulls
FROM
      `DATASET-PROJECT.DATASET-NAME.events_*`
GROUP BY
      imageName
ORDER BY
      numberOfPulls DESC

donde

DATASET-PROJECT es el proyecto que contiene tu conjunto de datos.
DATASET-NAME es el nombre del conjunto de datos.

En el siguiente ejemplo, se muestra el resultado de la consulta. En la columna imageName, puedes revisar la frecuencia de extracción de las imágenes que no se almacenan en Container Registry o Artifact Registry.

Copia imágenes en Container Registry

Una vez que identificaste imágenes de registros de terceros, estás listo para copiarlas en Container Registry. La herramienta gcrane te ayuda con el proceso de copiado.

Crea un archivo de texto images.txt en Cloud Shell con los nombres de las imágenes que identificaste. Por ejemplo:
```
ubuntu:18.04
debian:buster
hello-world:latest
redis:buster
jupyter/tensorflow-notebook
```

Descarga gcrane.

  GO111MODULE=on go get github.com/google/go-containerregistry/cmd/gcrane

Crea una secuencia de comandos llamada copy_images.sh para copiar tu lista de archivos.

Nota: En esta secuencia de comandos y en las instrucciones de esta página, se supone que copias las imágenes a gcr.io. Si deseas usar un host multirregional diferente, como eu.gcr.io, debes actualizar las configuraciones y las secuencias de comandos de ejemplo según corresponda.
```
#!/bin/bash

images=$(cat images.txt)

if [ -z "${GCR_PROJECT}" ]
then
    echo ERROR: GCR_PROJECT must be set before running this
    exit 1
fi

for img in ${images}
do
    gcrane cp ${img} gcr.io/${GCR_PROJECT}/${img}
done
```
Haz que la secuencia de comandos sea ejecutable:
```
  chmod +x copy_images.sh
```
Ejecuta la secuencia de comandos para copiar los archivos:
```
GCR_PROJECT=${PROJECT}
./copy_images.sh
```

Verifica los permisos

De forma predeterminada, los servicios de CI/CD de Google Cloud tienen acceso a Container Registry en el mismo proyecto de Google Cloud.

Cloud Build puede enviar y extraer imágenes
Los entornos de ejecución como GKE, Cloud Run, el entorno flexible de App Engine, y Compute Engine puede extraer imágenes.

Si necesitas enviar o extraer imágenes entre proyectos o si usas herramientas de terceros en tu canalización que necesitan acceder a Container Registry, asegúrate de que los permisos estén configurados de forma correcta antes de actualizar y volver a implementar tus cargas de trabajo.

Para obtener más información, consulta la documentación sobre el control de acceso.

Actualiza los manifiestos para que hagan referencia a Container Registry

Actualiza tus Dockerfiles y tus manifiestos para que hagan referencia a Container Registry, en lugar de al registro de terceros.

En el siguiente ejemplo, se muestra un manifiesto que hace referencia a un registro de terceros:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Esta versión actualizada del manifiesto apunta a la imagen en Container Registry:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: gcr.io/<GCR_PROJECT>/nginx:1.14.2
        ports:
        - containerPort: 80

Para una gran cantidad de manifiestos, usa sed o cualquier otra herramienta que pueda controlar las actualizaciones en muchos archivos de texto.

Vuelve a implementar las cargas de trabajo

Vuelve a implementar las cargas de trabajo con tus manifiestos actualizados.

Ejecuta la siguiente consulta en la consola de BigQuery para hacer un seguimiento de las extracciones de imágenes nuevas:

SELECT`

FORMAT_TIMESTAMP("%D %R", timestamp) as timeOfImagePull,
REGEXP_EXTRACT(jsonPayload.message, r'"(.*?)"') AS imageName,
COUNT(*) AS numberOfPulls
FROM
  `image_pull_logs.events_*`
GROUP BY
  timeOfImagePull,
  imageName
ORDER BY
  timeOfImagePull DESC,
  numberOfPulls DESC

Todas las extracciones de imágenes nuevas deben ser de Container Registry y contener la cadena gcr.io.

(Opcional) Bloquear imágenes extraídas de registros de terceros

En el caso de los clústeres de GKE que usan la autorización binaria, la política que definas bloqueará automáticamente las extracciones de fuentes no confiables. Para asegurarte de que la política no bloquee las imágenes que migraste, agrégalas a la lista de exenciones. En estas instrucciones, se describe cómo especificar una exención para todas las imágenes almacenadas en Container Registry dentro de tu proyecto.

Cuando actualices la política por primera vez, considera habilitar el modo de ejecución de prueba. En lugar de bloquear imágenes, la autorización binaria crea entradas de registro de auditoría para que puedas identificar las imágenes pendientes de registros de terceros que necesitas migrar a Container Registry.

Para obtener más información sobre la configuración de políticas de implementación, consulta la documentación sobre la autorización binaria.

Ve a la página Autorización binaria
Haz clic en Editar política.
En Regla predeterminada del proyecto, habilita el Modo de ejecución de prueba.
En Imágenes exentas de reglas de implementación, deja seleccionada la opción Confiar en todas las imágenes de sistema proporcionadas por Google.
Expande Rutas de imagen.
Agrega la ruta a tus imágenes como una exención de la regla de proyecto predeterminada:
1. En la parte inferior de la lista de imágenes, haz clic en Agregar imágenes.
2. Ingresa la ruta de acceso a la imagen de tu proyecto de Google Cloud. Por ejemplo, gcr.io/my-project/* exime todas las imágenes del proyecto. my-project
Repite el paso anterior para otros proyectos que contengan imágenes que deseas implementar.

Revisa los eventos de ejecución de prueba en Logging para tus implementaciones. Migra las imágenes restantes que extraes con frecuencia de los registros de terceros. Cuando todas tus imágenes se migran, puedes editar la política para inhabilitar el modo de ejecución imágenes de fuentes no confiables.