Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Déployer une application de serveur Web conteneurisée

Ce tutoriel explique comment importer une application conteneurisée dans un environnement d'appliance Google Distributed Cloud (GDC) sous air gap et l'exécuter dans cet environnement. 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 d'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 l' Google Cloud Artifact Registry.

Objectifs

Transférer une image de conteneur vers le registre Harbor géré.
Déployer 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 à l'administrateur IAM de votre organisation de vous accorder les rôles suivants :
- Rôle d'administrateur d'espace de noms (namespace-admin) pour l'espace de noms de votre projet. Ce rôle est requis pour déployer des charges de travail de conteneur dans votre projet.
- Rôle de 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é vous permettant 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 conteneurs :

Vous avez besoin de l'URL de tear-harbor. Affichez l'URL de l'instance :
```
gdcloud harbor instances describe tear-harbor --project=tear
```
Le résultat ressemble à harbor-1.org-1.zone1.google.gdc.test.
Définissez l'URL de l'instance en tant que variable à utiliser ultérieurement dans le tutoriel :
```
export INSTANCE_URL=INSTANCE_URL
```
Saisissez l'URL de l'instance sans le préfixe https://.
Avant de créer le projet, vous devez vous connecter à Harbor à l'aide de l'URL de l'étape précédente. Ouvrez cette URL dans un navigateur et connectez-vous à 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 en tant que variable à utiliser ultérieurement 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 approuve Harbor en tant que service. Pour en savoir plus, consultez Configurer Docker pour qu'il approuve l'autorité de certification racine Harbor.
Configurez l'authentification Docker pour 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 sous air gap :
1. Demandez à votre IO les informations suivantes :
  1. L'URL externe du cluster Harbor.
  2. Le 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 dans ce dossier.

Créer un secret d'extraction d'image Kubernetes

Étant donné que vous utilisez un projet Harbor privé, vous devez créer un secret d'extraction d'image Kubernetes.

Ajoutez un compte de robot de projet Harbor. Suivez la procédure décrite dans l'interface utilisateur Harbor pour créer le compte de 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 nouveau nom de compte de robot de projet, qui présente la syntaxe suivante :
```
<PREFIX><PROJECT_NAME>+<ACCOUNT_NAME>
```
Par exemple, le format du nom de compte de robot de projet ressemble à harbor@library+artifact-account.

Pour en savoir plus sur la recherche du nom de compte de robot de 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 votre compte de robot de projet Harbor et votre jeton secret :
```
docker login ${INSTANCE_URL}
```
Lorsque vous y êtes invité, insérez le nom de compte de robot de projet pour le Username et le jeton secret pour le Password.
Définissez un nom arbitraire pour le secret d'extraction d'image :
```
export SECRET=SECRET
```
Créez le secret requis pour l'extraction d'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 Google Cloud public.

Extrayez l'image nginx du Google Cloud registreArtifact Registry 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 un tag à l'image locale avec le 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 d'instances dupliquées, 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 comporte des instances dupliquées, ou pods. Un Deployment pod ne contient qu'un seul conteneur : l'nginx image de conteneur. 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 Deployment et Service Kubernetes :

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 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
```

Étape suivante

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