Cette page a été traduite par l'API Cloud Translation.

Migrer des images de conteneurs à partir d'un registre tiers

Si vous extrayez directement certaines images de conteneurs à partir de registres tiers afin de les déployer dans des environnements Google Cloud tels que Google Kubernetes Engine ou Cloud Run, les limites de débit sur les extractions d'images ou les pannes tierces peuvent perturber vos builds et vos déploiements. Cette page explique comment identifier et copier ces images dans Artifact Registry afin de parvenir à une gestion des images de conteneur consolidée et cohérente.

Artifact Registry ne surveille pas les registres tiers pour détecter les mises à jour que vous copiez dans Artifact Registry. Si vous souhaitez incorporer un nouveau d'une image dans votre pipeline, vous devez la transférer Artifact Registry.

Présentation de la migration

La migration de vos images de conteneurs comprend les étapes suivantes :

Configurer les prérequis.
Identifier les images à migrer.
- Rechercher les références à des registres tiers dans vos fichiers Dockerfile et vos fichiers manifestes de déploiement.
- Déterminer la fréquence d'extraction des images depuis des registres tiers à l'aide de Cloud Logging et BigQuery.
Copiez les images identifiées dans Artifact Registry.
Vérifier que les autorisations d'accès au registre sont correctement configurées, en particulier si Artifact Registry et votre environnement de déploiement Google Cloud se trouvent dans des projets différents.
Mettre à jour les fichiers manifestes pour vos déploiements.
Redéployer vos charges de travail.

Avant de commencer

Vérifiez vos autorisations. Vous devez disposer du rôle IAM Propriétaire ou Éditeur dans les projets dans lesquels vous migrez des images vers Artifact Registry.
Accéder à la page de sélection du projet
1. Sélectionnez le projet Google Cloud dans lequel vous souhaitez utiliser Artifact Registry.
2. Dans la console Google Cloud, accédez à Cloud Shell.
3. Recherchez votre ID de projet et définissez-le dans Cloud Shell. Remplacez YOUR_PROJECT_ID par l'ID de votre projet :
```
gcloud config set project YOUR_PROJECT_ID
```

Exportez les variables d'environnement suivantes :

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

Activez les API BigQuery, Artifact Registry et Cloud Monitoring à l'aide de la commande suivante :

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

Si vous n'utilisez pas Artifact Registry à l'heure actuelle, configurez un dépôt pour vos images:
- Créer un dépôt
- Configurer l'authentification pour les clients tiers qui nécessitent un accès au dépôt.
Vérifiez que Go version 1.13 ou ultérieure est installé.
- Vérifiez la version d'une installation Go existante à l'aide de la commande suivante :
```
go version
```
- Si vous devez installer ou mettre à jour Go, consultez la documentation d'installation de Go.

Coûts

Ce guide utilise les composants facturables suivants de Google Cloud :

Identifier les images à migrer

Recherchez dans les fichiers que vous utilisez pour créer et déployer vos images de conteneurs des références à des registres tiers, puis vérifiez à quelle fréquence vous extrayez les images.

Identifier les références dans les fichiers Dockerfile

Effectuez cette étape dans un emplacement où sont stockés vos fichiers Dockerfile. Il peut s'agir de l'emplacement où votre code est extrait localement, ou dans Cloud Shell si les fichiers sont disponibles sur une VM.

Dans le répertoire contenant vos fichiers Dockerfile, exécutez la commande suivante :

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

Le résultat ressemble à l'exemple suivant :

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

Cette commande recherche tous les fichiers Dockerfile de votre répertoire et identifie la ligne "FROM". Ajustez la commande selon vos besoins pour qu'elle corresponde à la manière dont vous stockez vos fichiers Dockerfile.

Identifier les références dans les fichiers manifestes

Effectuez cette étape dans un emplacement où sont stockés vos fichiers manifestes GKE ou Cloud Run. Il peut s'agir de l'emplacement où votre code est extrait localement, ou dans Cloud Shell si les fichiers sont disponibles sur une VM.

Dans le répertoire contenant vos fichiers manifestes GKE ou Cloud Run, exécutez la commande suivante :
```
grep -inr -H --include \*.yaml "image:" . | grep -i -v -E 'docker.pkg.dev|gcr.io'
```
Exemple de résultat :
```
./code/deploy/k8s/ubuntu16-04.yaml:63: image: busybox:1.31.1-uclibc
./code/deploy/k8s/master.yaml:26:      image: kubernetes/redis:v1
```
Cette commande examine tous les fichiers YAML de votre répertoire et identifie la ligne image:, puis procède aux ajustements nécessaires en fonction du stockage des fichiers manifestes.
Pour répertorier les images actuellement exécutées sur un cluster, exécutez la commande suivante :
```
  kubectl get all --all-namespaces -o yaml | grep image: | grep -i -v -E 'docker.pkg.dev|gcr.io'
```
Cette commande renvoie tous les objets s'exécutant dans le cluster Kubernetes actuellement sélectionné et obtient leurs noms d'image.

Exemple de résultat :
```
- image: nginx
  image: nginx:latest
    - image: nginx
    - image: nginx
```

Exécutez cette commande pour tous les clusters GKE de tous les projets Google Cloud pour une couverture totale.

Identifier la fréquence d'extraction depuis un registre tiers

Dans les projets qui extraient à partir de registres tiers, utilisez les informations sur la fréquence d'extraction d'image pour déterminer si votre utilisation est proche ou supérieure aux limites de débit appliquées par le registre tiers.

Collecter les données des journaux

Créez un récepteur de journaux pour exporter des données vers BigQuery. Un récepteur de journaux inclut une destination, ainsi qu'un filtre qui sélectionne les entrées de journal à exporter. Vous pouvez créer un récepteur en interrogeant des projets individuels, ou utiliser un script pour collecter des données entre différents projets.

Pour créer un récepteur pour un seul projet, procédez comme suit :

Accéder à l'explorateur de journaux
Choisissez un projet Google Cloud.
Dans l'onglet Générateur de requête, saisissez la requête suivante :
```
  resource.type="k8s_pod"
  jsonPayload.reason="Pulling"
```
Modifiez le filtre d'historique en passant de Dernière heure à 7 derniers jours.
Cliquez sur Exécuter la requête.
Après avoir vérifié que les résultats s'affichent correctement, cliquez sur Actions > Créer un récepteur.
Dans la liste des récepteurs, sélectionnez Ensemble de données BigQuery, puis cliquez sur Suivant.
Dans le panneau "Modifier le récepteur", procédez comme suit :
- Dans le champ Nom du récepteur, saisissez image_pull_logs.
- Dans le champ Destination du récepteur, créez un nouvel ensemble de données ou choisissez un ensemble de données de destination dans un autre projet.
Cliquez sur Créer un récepteur.

Pour créer un récepteur pour plusieurs projets, procédez comme suit :

Ouvrez Cloud Shell.

Exécutez les commandes suivantes dans 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

Où :

PROJECT-LIST est une liste d'ID de projet Google Cloud, séparés par des espaces. Par exemple, project1 project2 project3.
DATASET-PROJECT est le projet dans lequel vous souhaitez stocker l'ensemble de données.
DATASET-NAME est le nom de l'ensemble de données, par exemple image_pull_logs.

Après la création d'un récepteur, le transfert des données dans les tables BigQuery prend du temps, en fonction de la fréquence à laquelle les images sont extraites.

Requête pour la fréquence d'extraction

Une fois que vous disposez d'un exemple représentatif d'extractions d'images effectuées par vos builds, exécutez une requête pour la fréquence d'extraction.

Accédez à la console BigQuery.

Exécutez la requête suivante :

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

Où :

DATASET-PROJECT est le projet qui contient votre ensemble de données.
DATASET-NAME est le nom de l'ensemble de données.

L'exemple suivant montre le résultat de la requête. Dans la colonne imageName, vous pouvez consulter la fréquence d'extraction pour les images qui ne sont pas stockées dans Artifact Registry ou Container Registry.

Copier des images dans Artifact Registry

Une fois que vous avez identifié des images provenant de registres tiers, vous pouvez les copier dans Artifact Registry. L'outil gcrane vous aide avec le processus de copie.

Créez un fichier texte images.txt dans Cloud Shell avec le nom des images que vous avez identifiées. Exemple :
```
ubuntu:18.04
debian:buster
hello-world:latest
redis:buster
jupyter/tensorflow-notebook
```

Téléchargez gcrane.

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

Créez un script nommé copy_images.sh pour copier votre liste de fichiers.

#!/bin/bash

images=$(cat images.txt)

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

for img in ${images}
do
    gcrane cp ${img} LOCATION-docker.pkg.dev/${AR_PROJECT}/${img}
done

Remplacez LOCATION par le region ou un emplacement multirégional un dépôt de clés.

Rendez le script exécutable :

  chmod +x copy_images.sh

Exécutez le script pour copier les fichiers :
```
AR_PROJECT=${PROJECT}
./copy_images.sh
```

Vérifier les autorisations

Par défaut, les services CI/CD de Google Cloud ont accès à Artifact Registry dans le même projet Google Cloud.

Cloud Build peut transférer et extraire des images.
Les environnements d'exécution tels que GKE, Cloud Run l'environnement flexible App Engine et Compute Engine peut extraire des images.

Si vous devez transférer ou extraire des images de plusieurs projets, ou si votre pipeline utilise des outils tiers qui doivent accéder à Artifact Registry, assurez-vous que les autorisations sont correctement configurées avant de mettre à jour et de redéployer vos charges de travail.

Pour en savoir plus, consultez la documentation sur le contrôle des accès.

Mettre à jour les fichiers manifestes pour référencer Artifact Registry

Mettez à jour vos fichiers Dockerfile et vos fichiers manifestes pour faire référence à Artifact Registry plutôt qu'au registre tiers.

L'exemple suivant illustre un fichier manifeste référençant un registre tiers :

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

Cette version mise à jour du fichier manifeste pointe vers une image sur us-docker.pkg.dev

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: us-docker.pkg.dev/<AR_PROJECT>/nginx:1.14.2
        ports:
        - containerPort: 80

Pour un grand nombre de fichiers manifestes, utilisez sed ou un autre outil capable de gérer des mises à jour dans de nombreux fichiers texte.

Redéployer des charges de travail

Redéployez les charges de travail avec vos fichiers manifestes mis à jour.

Effectuez le suivi des nouvelles extractions d'images en exécutant la requête suivante dans la console BigQuery :

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

Toutes les nouvelles extractions d'images doivent provenir de Artifact Registry et contenir la chaîne docker.pkg.dev.