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

Déployer une application de serveur Web conteneurisée

Ce tutoriel explique comment importer une application de conteneur dans un environnement d'appliance Google Distributed Cloud (GDC) isolé et comment exécuter cette application dans l'environnement d'appliance. Dans ce tutoriel, vous apprendrez à créer des projets Harbor, à importer des images dans Harbor et à créer des charges de travail. Une charge de travail conteneurisée s'exécute dans un espace de noms de projet.

L'environnement de l'appliance GDC sous air gap est fourni avec un registre Harbor préconfiguré appelé tear-harbor dans un projet GDC appelé tear. Vous utiliserez ce registre dans cet exemple.

Ce tutoriel utilise un exemple d'application de serveur Web disponible dans le Google Cloud dépôt Artifact Registry.

Objectifs

Transférez une image de conteneur vers le registre Harbor géré.
Déployez l'exemple d'application de conteneur sur le cluster.

Avant de commencer

Assurez-vous de disposer d'un projet pour gérer vos déploiements conteneurisés. Créez un projet si vous n'en avez pas.
Définissez l'espace de noms de votre projet en tant que variable d'environnement :
```
export NAMESPACE=PROJECT_NAMESPACE
```
Téléchargez et installez la gdcloud CLI.
Demandez à votre administrateur IAM de l'organisation de vous accorder les rôles suivants :
- Rôle Administrateur d'espace de noms (namespace-admin) pour l'espace de noms de votre projet. Ce rôle est nécessaire pour déployer des charges de travail de conteneur dans votre projet.
- Rôle Lecteur d'instance Harbor (harbor-instance-viewer) pour l'espace de noms de votre projet. Ce rôle est requis pour afficher et sélectionner une instance Harbor.
- Rôle de créateur de projet Harbor (harbor-project-creator) pour l'espace de noms de votre projet. Ce rôle est requis pour accéder à un projet Harbor et le gérer.
Connectez-vous au cluster Kubernetes et générez son fichier kubeconfig avec une identité utilisateur. Assurez-vous de définir le chemin d'accès kubeconfig en tant que variable d'environnement :
```
export KUBECONFIG=CLUSTER_KUBECONFIG
```

Créer un projet Harbor dans le registre

GDC fournit Harbor en tant que service, qui est un service entièrement géré qui vous permet de stocker et de gérer des images de conteneurs à l'aide de Harbor.

Pour utiliser Harbor en tant que service, vous devez créer un projet Harbor dans l'instance de registre tear-harbor afin de gérer vos images de conteneur :

Vous avez besoin de l'URL de tear-harbor. Listez l'URL de l'instance :
```
gdcloud harbor instances describe tear-harbor --project=tear
```
Le résultat est semblable à harbor-1.org-1.zone1.google.gdc.test.
Définissez l'URL de l'instance en tant que variable à utiliser plus tard dans le tutoriel :
```
export INSTANCE_URL=INSTANCE_URL
```
Avant de créer le projet, vous devez vous connecter à Harbor à l'aide de l'URL de l'étape précédente. Utilisez un navigateur pour ouvrir cette URL et vous connecter à l'instance Harbor.
Créez le projet Harbor :
```
gdcloud harbor harbor-projects create HARBOR_PROJECT \
    --project=tear \
    --instance=tear-harbor
```
Remplacez HARBOR_PROJECT par le nom du projet Harbor à créer. Vous ne pouvez pas créer le projet Harbor dans un espace de noms de projet. Vous devez utiliser le projet tear.
Définissez le nom du projet Harbor comme variable à utiliser plus tard dans le tutoriel :
```
export HARBOR_PROJECT=HARBOR_PROJECT
```

Configurer Docker

Pour utiliser Docker dans votre registre Harbor, procédez comme suit :

Configurez Docker pour qu'il fasse confiance à Harbor en tant que service. Pour en savoir plus, consultez Configurer Docker pour qu'il fasse confiance à l'autorité de certification racine Harbor.
Configurez l'authentification Docker sur Harbor. Pour en savoir plus, consultez Configurer l'authentification Docker pour les instances de registre Harbor.
Étant donné que tear-harbor est un registre Harbor préconfiguré, vous devez approuver le certificat signé par l'autorité de certification interne Google Distributed Cloud air-gapped :
1. Demandez à votre responsable des opérations d'insertion de vous fournir les informations suivantes :
  1. URL externe du cluster Harbor.
  2. Fichier .crt de l'autorité de certification interne Google Distributed Cloud sous air gap. Le fichier est généralement stocké dans le plan de contrôle en tant que secret sous le nom trust-store-internal-only dans l'espace de noms anthos-creds.
2. Comme à l'étape précédente, créez un dossier portant le nom de l'URL externe du cluster Harbor et conservez le fichier .crt à l'intérieur.

Créer un secret Kubernetes pour l'extraction d'images

Étant donné que vous utilisez un projet Harbor privé, vous devez créer un secret Kubernetes pour extraire les images.

Ajoutez un compte robot de projet Harbor. Suivez la procédure décrite dans l'interface utilisateur Harbor pour créer le compte robot et copier le jeton secret du robot : https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#add-a-robot-account.
Notez le nom du nouveau compte de projet robot, qui suit la syntaxe suivante :
```
<PREFIX><PROJECT_NAME>+<ACCOUNT_NAME>
```
Par exemple, le format du nom de compte de projet robot ressemble à harbor@library+artifact-account.

Pour savoir comment trouver le nom de compte de robot de votre projet dans Harbor, consultez la documentation de Harbor : https://goharbor.io/docs/2.8.0/working-with-projects/project-configuration/create-robot-accounts/#view-project-robot-accounts.
Connectez-vous à Docker avec le compte robot et le jeton secret de votre projet Harbor :
```
docker login ${INSTANCE_URL}
```
Lorsque vous y êtes invité, insérez le nom du compte de projet du robot pour Username et le jeton secret pour Password.
Définissez un nom arbitraire pour le secret d'extraction d'image :
```
export SECRET=SECRET
```
Créez le secret requis pour l'extraction de l'image :
```
kubectl create secret docker-registry ${SECRET}  \
    --from-file=.dockerconfigjson=DOCKER_CONFIG \
    -n NAMESPACE
```
Remplacez les éléments suivants :
- DOCKER_CONFIG : chemin d'accès au fichier .docker/config.json.
- NAMESPACE : espace de noms du secret que vous créez.

Transférer une image de conteneur vers le registre Harbor géré

Pour ce tutoriel, vous allez télécharger et transférer l'image du serveur Web nginx vers le registre Harbor géré, puis l'utiliser pour déployer un exemple d'application de serveur Web nginx sur un cluster Kubernetes. L'application de serveur Web nginx est disponible dans le registre Artifact Registry public Google Cloud .

Extrayez l'image nginx d'Artifact Registry Google Cloud vers votre poste de travail local à l'aide d'un réseau externe :
```
docker pull gcr.io/cloud-marketplace/google/nginx:1.25
```
Définissez le nom de l'image. Le format d'un nom d'image complet est le suivant :
```
${INSTANCE_URL}/${HARBOR_PROJECT}/nginx
```

Ajoutez à l'image locale le tag correspondant au nom du dépôt :

docker tag gcr.io/cloud-marketplace/google/nginx:1.25 ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25

Transférez l'image de conteneur nginx vers votre registre Harbor géré :
```
docker push ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
```

Déployer l'exemple d'application de conteneur

Vous êtes maintenant prêt à déployer l'image de conteneur nginx sur le cluster d'appliance.

Kubernetes représente les applications sous forme de ressources Pod, qui sont des unités évolutives contenant un ou plusieurs conteneurs. Le pod est la plus petite unité déployable dans Kubernetes. Généralement, vous déployez les pods sous la forme d'un ensemble d'instances dupliquées pouvant être mises à l'échelle et réparties sur votre cluster. Pour déployer un ensemble de répliques, vous pouvez utiliser un Deployment Kubernetes.

Dans cette section, vous allez créer un Deployment Kubernetes pour exécuter l'application de conteneur nginx sur votre cluster. Ce déploiement possède des répliques ou des pods. Un pod Deployment ne contient qu'un seul conteneur : l'image de conteneur nginx. Vous créez également une ressource Service qui fournit aux clients un moyen stable d'envoyer des requêtes aux pods de votre Deployment.

Déployez le serveur Web nginx :

Créez et déployez les ressources personnalisées Kubernetes Deployment et Service :

kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: ${INSTANCE_URL}/${HARBOR_PROJECT}/nginx:1.25
        ports:
        - containerPort: 80
      imagePullSecrets:
      - name: ${SECRET}
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - port: 80
      protocol: TCP
  type: LoadBalancer
EOF

Vérifiez que les pods ont été créés par le déploiement :

kubectl get pods -l app=nginx -n ${NAMESPACE}

Le résultat ressemble à ce qui suit :

NAME                                READY     STATUS    RESTARTS   AGE
nginx-deployment-1882529037-6p4mt   1/1       Running   0          1h
nginx-deployment-1882529037-p29za   1/1       Running   0          1h
nginx-deployment-1882529037-s0cmt   1/1       Running   0          1h

Créez une règle de réseau pour autoriser tout le trafic réseau vers l'espace de noms :

kubectl --kubeconfig ${KUBECONFIG} -n ${NAMESPACE} \
create -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  annotations:
  name: allow-all
spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  podSelector: {}
  policyTypes:
  - Ingress
EOF

Exportez l'adresse IP du service nginx :

  export IP=`kubectl --kubeconfig=${KUBECONFIG} get service nginx-service \
      -n ${NAMESPACE} -o jsonpath='{.status.loadBalancer.ingress[*].ip}'`

Testez l'adresse IP du serveur nginx à l'aide de curl :
```
  curl http://$IP
```

Étapes suivantes

Consultez la documentation sur les conteneurs pour savoir comment les gérer.