Étape 7 : Installer un environnement d'exécution hybride

Activer l'accès du synchronisateur

Pour activer l'accès du synchronisateur, procédez comme suit :

Créez un compte de service Google Cloud et attribuez-lui le rôle Administrateur de l'organisation Apigee. Ce compte de service sera utilisé pour authentifier un appel d'API que vous effectuerez ultérieurement. La console GCP permet de créer facilement le compte de service. Pour obtenir des instructions, consultez la page Créer et gérer des comptes de service dans la documentation de GCP.
Par exemple, les commandes gcloud suivantes créent le compte de service et lui attribuent le rôle Administrateur de l'organisation Apigee :
1. Créez le compte :
```
gcloud iam service-accounts create apigee-org-admin \
    --display-name="apigee-org-admin"
```
  Où apigee-org-admin est le nom du compte de service que vous créez. "apigee-org-admin" est recommandé pour ce tutoriel.
2. Attribuez le rôle Administrateur de l'organisation Apigee au compte de service :
```
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:apigee-org-admin@$PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/apigee.admin"
```
  Où :
  - $PROJECT_ID est le nom du projet Google Cloud que vous avez créé à l'étape 2 : Créer un projet Google Cloud.
  - apigee-org-admin est le nom du compte de service que vous venez de créer.
  - Le rôle roles/apigee.admin correspond au rôle roles/apigee.admin.
Téléchargez la clé du compte de service sur votre système. Utilisez la commande suivante pour télécharger la clé dans votre répertoire service-accounts/. Pour en savoir plus, consultez les instructions de la section Créer des clés de compte de service de la documentation de GCP.
1. Assurez-vous que vous vous trouvez dans le répertoire /hybrid-base-directory/hybrid-files/.
2. Téléchargez la clé :
```
gcloud iam service-accounts keys create ./service-accounts/$PROJECT_ID-apigee-org-admin.json \
  --iam-account apigee-org-admin@$PROJECT_ID.iam.gserviceaccount.com
```
  Le résultat devrait ressembler à ceci :
```
created key [a0b1c2d3e4f5a0b1c2d3e4f5a0b1c2d3e4f5a0b1] of type [json] as [./service-accounts/hybrid-
example-apigee-org-admin.json] for [apigee-org-admin@my-hybrid.iam.gserviceaccount.com]
$ 
```
Vérifiez le chemin d'accès à la clé de compte de service Administrateur de l'organisation Apigee à l'aide de la commande suivante :
```
ls service-accounts/*admin*
```
Le résultat doit se présenter sous la forme suivante :
```
service-accounts/hybrid-example-apigee-org-admin.json
```
Créez une variable d'environnement ORG_ADMIN_ACCOUNT contenant le nom du fichier de clé. Par exemple :
```
export ORG_ADMIN_ACCOUNT="hybrid-example-apigee-org-admin.json"
```

Exécutez les commandes suivantes pour obtenir un jeton :

export GOOGLE_APPLICATION_CREDENTIALS=./service-accounts/$ORG_ADMIN_ACCOUNT
export TOKEN=$(gcloud auth application-default print-access-token)

Récupérez l'adresse e-mail de votre compte de service apigee-synchronizer à l'aide de la commande suivante :
```
gcloud iam service-accounts list --filter "apigee-synchronizer"
```
Si elle correspond au modèle apigee-synchronizer$ORG_NAME.iam.gserviceaccount.com, vous pouvez utiliser ce modèle à l'étape suivante.
Appelez l'API setSyncAuthorization afin d'activer les autorisations requises pour le synchronisateur à l'aide de la commande suivante :
```
curl -X POST -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type:application/json" \
  "https://apigee.googleapis.com/v1/organizations/$ORG_NAME:setSyncAuthorization" \
   -d '{"identities":["'"serviceAccount:apigee-synchronizer@$ORG_NAME.iam.gserviceaccount.com"'"]}'
```
Où :
- $ORG_NAME : nom de votre organisation hybride.
- apigee-synchronizer$ORG_NAME.iam.gserviceaccount.com : adresse e-mail associée au compte de service apigee-syncnronizer.

Afin de vérifier que le compte de service a été défini, utilisez la commande suivante pour appeler l'API et obtenir une liste de comptes de service :

curl -X POST -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type:application/json" \
  "https://apigee.googleapis.com/v1/organizations/$ORG_NAME:getSyncAuthorization" \
   -d ''

La sortie ressemble à ceci :

{
   "identities":[
      "serviceAccount:my-synchronizer-manager-service_account@my_project_id.iam.gserviceaccount.com"
   ],
   "etag":"BwWJgyS8I4w="
}

Appliquer la configuration au cluster

Pour installer Apigee hybrid sur votre cluster, procédez comme suit :

Vérifiez que vous êtes bien dans le répertoire hybrid-base-directory/hybrid-files.
Vérifiez que kubectl est défini sur le bon contexte à l'aide de la commande suivante. Le contexte actuel doit être défini sur le cluster au sein duquel vous déployez Apigee hybrid.
```
kubectl config get-contexts
```
Pour les plates-formes AWS sur GKE, EKS et GKE on Prem uniquement, vérifiez que la variable KUBECONFIG est définie à l'aide de la commande suivante.
```
echo $KUBECONFIG
```
Effectuez une simulation d'initialisation. Exécutez la commande init avec l'option --dry-run. L'exécution d'une simulation vous permet de rechercher les erreurs éventuelles avant que des modifications ne soient apportées au cluster.
Dans la version 1.4.4 d'Apigee hybrid, la syntaxe de l'option --dry-run dépend de la version de kubectl que vous exécutez. Vérifiez la version de kubectl à l'aide de la commande suivante :
```
kubectl version
```
kubectl version 1.17 et antérieure :
```
$APIGEECTL_HOME/apigeectl init -f overrides/overrides.yaml --dry-run=true
```
kubectl version 1.18 et ultérieure :
```
$APIGEECTL_HOME/apigeectl init -f overrides/overrides.yaml --dry-run=client
```
Si aucune erreur ne s'affiche, exécutez la commande init comme suit :
```
$APIGEECTL_HOME/apigeectl init -f overrides/overrides.yaml
```
La commande init installe les services de déploiement Apigee, le contrôleur de déploiement Apigee ainsi que le webhook d'admission Apigee.
Pour vérifier l'état du déploiement, vous pouvez exécuter les commandes suivantes :
```
$APIGEECTL_HOME/apigeectl check-ready -f overrides/overrides.yaml
kubectl get pods -n apigee-system
kubectl get pods -n istio-system
```
Lorsque les pods sont prêts, passez à l'étape suivante.
Effectuez une simulation d'intallation. Exécutez la commande apply avec l'option --dry-run.
kubectl version 1.17 et antérieure :
```
$APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml --dry-run=true
```
kubectl version 1.18 et ultérieure :
```
$APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml --dry-run=client
```
Si aucune erreur ne s'affiche, vous pouvez appliquer les composants d'exécution spécifiques à Apigee au cluster à l'aide de la commande suivante :
```
$APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml
```
Pour vérifier l'état du déploiement, exécutez la commande suivante :
```
$APIGEECTL_HOME/apigeectl check-ready -f overrides/overrides.yaml
```
Répétez cette étape jusqu'à ce que tous les pods soient prêts. Le démarrage des pods peut prendre plusieurs minutes.