Utiliser la page Applications GKE dans la console Google Cloud

Ce tutoriel explique comment utiliser la page Applications Google Kubernetes Engine (GKE) dans Google Cloud Console.

Lorsque vous adoptez Kubernetes pour de nombreuses applications et ressources, il peut devenir difficile d'identifier et de suivre les différents composants associés à une même application. Lorsque vous déployez plusieurs applications dans chaque espace de noms, il peut être difficile de savoir quelles ressources sont associées à une application donnée. En outre, il est fréquent de devoir rechercher dans différents emplacements la documentation et les métadonnées décrivant les applications, leurs propriétaires, ou encore des informations sur la manière dont vous pouvez interagir avec les services.

GKE vous aide à relever ces défis avec la page Applications :

Vue partielle de la page "Applications" affichant une liste d'applications ainsi que leurs différentes propriétés.

La page Applications est une ressource indépendante au sein de votre architecture, qui décrit les métadonnées de votre système. Vous pouvez utiliser cette page pour organiser visuellement vos ressources sans modifier l'architecture. En définissant des valeurs dans un fichier YAML, vous pouvez regrouper toutes les ressources de vos applications et inclure des métadonnées essentielles pour votre équipe chargée des opérations. La création, la modification et la suppression du fichier YAML n'affectent pas les ressources existantes. Vous pouvez donc immédiatement travailler avec des ressources sans risque pour votre système.

Pour illustrer cette page, ce tutoriel explique comment mettre en œuvre la ressource Application Kubernetes sur une application et ajouter des métadonnées définies par l'utilisateur afin d'organiser et de simplifier la gestion de l'application dans GKE.

Ce tutoriel est destiné aux développeurs qui créent des applications à exécuter dans GKE. Nous partons du principe que vous connaissez les concepts de base de Kubernetes et que vous avez une certaine expérience de l'écriture de fichiers YAML pour les ressources Kubernetes.

Objectifs

Présenter la ressource Application Kubernetes.
Ajouter la ressource Application Kubernetes à une architecture existante.
Créer et afficher des informations personnalisées concernant une application via la console Google Cloud.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Activer les API Compute Engine and Kubernetes Engine.
Activer les API
Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

Exécutez les commandes de ce tutoriel dans Cloud Shell ou l'éditeur Cloud Shell.

Préparer l'environnement

Dans Cloud Shell, définissez les variables d'environnement pour votre projet :
```
export PROJECT_ID=PROJECT_ID
gcloud config set core/project $PROJECT_ID
gcloud config set compute/zone us-central1-c
```
Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.
Créez un cluster GKE :
```
gcloud container clusters create sample-cluster
```
Dans le cadre de ce tutoriel, vous exécutez des applications dans un cluster GKE par défaut.

Installer les exemples d'applications

Dans ce tutoriel, vous simulez plusieurs applications exécutées dans le même espace de noms à l'aide de l'exemple d'application Nginx de base et de l'exemple d'application Bank of Anthos.

Dans Cloud Shell, installez l'exemple d'application Nginx :
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/master/content/en/examples/application/web/web.yaml
```
Cette commande crée une ressource StatefulSet appelée web et un service appelé nginx. Dans la console Google Cloud, vous pouvez afficher ces ressources sur les charges de travail GKE et Services et Ingress.

Clonez le dépôt GitHub contenant l'exemple d'application Bank of Anthos :

git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
cd bank-of-anthos

Générez une clé SSH et stockez-la en tant que secret Kubernetes :

openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub

L'exemple d'application Bank of Anthos nécessite une clé SSH pour s'exécuter.

Déployez l'exemple d'application sur votre cluster :
```
kubectl apply -f kubernetes-manifests
```
Après quelques instants, vous pouvez afficher les ressources de l'application sur les pages suivantes de la console Google Cloud :
- La page Charges de travail
- La page Services et entrées
Veuillez noter les points suivants :
- Les ressources des exemples d'applications Nginx et Bank of Anthos sont imbriquées.
- Aucune ressource n'apparaît pour le moment sur la page Applications. Vous remplirez cette page Applications ultérieurement.

Préparer GKE

Les ressources affichées par la page Applications sont spécifiées avec le type de ressource "Application Kubernetes", qui est une définition de ressource personnalisée (CRD) fournie par le projet Open Source Kubernetes. Par défaut, la CRD d'application n'est pas activée dans Kubernetes. Certains services de GKE, tels que Marketplace et le Déploiement d'applications, installent la CRD d'application. Toutefois, si vous n'utilisez aucun de ces services, celle-ci n'est pas disponible par défaut.

Pour installer la CRD d'application, procédez comme suit :

Dans Cloud Shell, appliquez la CRD d'application une fois sur chaque cluster :

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/application/master/deploy/kube-app-manager-aio.yaml

(Facultatif) Une fois la commande exécutée, affichez la CRD d'application sur le cluster :

kubectl get crd

Le résultat suivant est une liste des CRD installées, y compris applications.app.k8s.io :

NAME                                    CREATED AT
applications.app.k8s.io                 2020-07-24T19:32:20Z
backendconfigs.cloud.google.com         2020-07-24T19:28:40Z
managedcertificates.networking.gke.io   2020-07-24T19:28:57Z
scalingpolicies.scalingpolicy.kope.io   2020-07-24T19:28:57Z
updateinfos.nodemanagement.gke.io       2020-07-24T19:28:57Z

Inclure les ressources d'application

Maintenant que la CRD d'application est disponible dans le cluster, l'étape suivante consiste à créer et déployer une instance de la ressource Application.

Comme la ressource Application est une ressource Kubernetes, elle a une structure similaire aux autres ressources Kubernetes, y compris les champs et les options pour apiVersion, kind, metadata et spec :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: ...
spec:
   ...

Dans les sections suivantes, vous allez travailler avec divers champs et options disponibles dans la ressource Application.

Créer la ressource Application de base

Vous pouvez ajouter la ressource Application à n'importe quel ensemble de ressources existant. Dans ce tutoriel, vous commencez avec une ressource vide et remplissez chaque section.

Dans Cloud Shell, créez et modifiez un fichier application.yaml dans le répertoire kubernetes-manifests :
```
touch kubernetes-manifests/application.yaml
edit kubernetes-manifests/application.yaml
```
L'éditeur Cloud Shell s'ouvre et affiche un fichier vide.

Collez les lignes suivantes pour définir votre première application :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"

Dans la barre de menus de Cloud Shell, cliquez sur Ouvrir le terminal.

Dans Cloud Shell, appliquez la ressource :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page Applications.

Accéder à la page Applications

La page Applications affiche les ressources que vous avez ajoutées :

Inclure des ressources par composant

La page Applications affiche l'application Bank of Anthos. Lorsque vous cliquez sur bank-of-anthos dans le champ Nom, des informations de base sur l'application s'affichent :

Les informations de l'application incluent le cluster, l'espace de noms et la date de création.

Vous pouvez ajouter différents types de composants à afficher dans la console Google Cloud. Par exemple, pour afficher les services, les déploiements et les objets StatefulSet, vous devez modifier la section componentKinds de la définition application.yaml, par exemple comme illustré ci-dessous :

spec:
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

Dans les étapes suivantes, vous ajoutez ces composants à la définition de la ressource Bank of Anthos :

Dans la barre de menus de Cloud Shell, cliquez sur Ouvrir l'éditeur.

Dans l'éditeur Cloud Shell, remplacez le contenu du fichier kubernetes-manifests/application.yaml en collant ce qui suit :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
spec:
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

L'ajout de la section spec ajoute Service, Deployment et StatefulSet à la définition de votre application.

Dans Cloud Shell, appliquez la ressource :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos

Les composants d'un type donné s'affichent :

Filtrer les ressources à l'aide de sélecteurs

À ce stade du tutoriel, la liste des composants inclut toutes les ressources des deux exemples d'applications, pour l'ensemble de composants défini dans l'intégralité de l'espace de noms. Par exemple, le schéma suivant montre le service nginx de l'exemple d'application Nginx et le déploiement transactionhistory de l'exemple d'application Bank of Anthos :

La liste des composants est générée à partir de toutes les applications figurant dans l'espace de noms.

Pour vous assurer que seules les ressources d'une seule application sont affichées, par exemple pour l'application Bank of Anthos, vous pouvez utiliser des sélecteurs pour identifier des ressources spécifiques. Pour voir comment les sélecteurs fonctionnent, ajoutez un libellé à votre ressource en procédant comme suit :

Dans Cloud Shell, ouvrez le fichier frontend.yaml :
```
edit kubernetes-manifests/frontend.yaml
```

Dans l'éditeur Cloud Shell, collez l'entrée label suivante après la ligne 18 :

labels:
    app.kubernetes.io/name: "bank-of-anthos"

La section metadata se présente comme suit :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:

Le fichier application.yaml complet se présente comme suit :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

Dans Cloud Shell, appliquez les ressources :
```
kubectl apply -f kubernetes-manifests/
```
Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos

La seule ressource correspondant à une étiquette spécifique s'affiche :

Appliquer des libellés à toutes les ressources à l'aide de `kustomize`

Appliquer manuellement des libellés à toutes les ressources d'une application peut s'avérer fastidieux. Les étapes suivantes montrent comment utiliser kustomize pour ajouter efficacement des libellés à toutes les ressources :

Dans Cloud Shell, téléchargez kustomize :

curl -s "https://raw.githubusercontent.com/\
kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash

Créez et modifiez un fichier kustomization.yaml :

touch kubernetes-manifests/kustomization.yaml
edit kubernetes-manifests/kustomization.yaml

Dans l'éditeur Cloud Shell, ajoutez les lignes suivantes à kustomization.yaml :
```
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
- accounts-db.yaml
- application.yaml
- balance-reader.yaml
- config.yaml
- contacts.yaml
- frontend.yaml
- ledger-db.yaml
- ledger-writer.yaml
- loadgenerator.yaml
- transaction-history.yaml
- userservice.yaml

commonLabels:
    app.kubernetes.io/name: "bank-of-anthos"
```
Dans cette définition kustomization.yaml, vous spécifiez les ressources auxquelles appliquer les modifications ainsi que les modifications à apporter. Dans ce cas, vous indiquez que toutes les ressources doivent avoir un libellé commun app.kubernetes.io/name: "bank-of-anthos".
Dans Cloud Shell, supprimez les anciennes ressources :
```
kubectl delete -f kubernetes-manifests/
```
Vous devez supprimer les anciennes ressources avant d'appliquer les nouvelles ressources spécifiées dans kustomization.yaml.
Appliquez les ressources à l'aide de l'option kustomize au lieu de l'option file :
```
./kustomize build kubernetes-manifests/ | kubectl apply -f -
```
Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos

La page d'informations affiche les ressources de l'exemple d'application Bank of Anthos, mais aucune ressource de l'exemple d'application Nginx :

Ajouter des métadonnées utiles dans l'affichage

Vous pouvez afficher des métadonnées personnalisées pour une application dans la console Google Cloud. Vous pouvez inclure la fonction de l'application, son propriétaire, où trouver des informations supplémentaires à son sujet, et la procédure pour s'y connecter. Ce type d'informations est utile dans différents cas d'utilisation, par exemple si vous exploitez plusieurs applications au sein de votre organisation.

Les sections suivantes décrivent certaines des métadonnées que vous pouvez ajouter.

Ajouter une description et une documentation

Vous pouvez ajouter une description et des liens qui apparaissent dans le panneau Informations sur l'application. Pour accéder à ce panneau à partir de la page Détails, cliquez sur Afficher le panneau d'informations.

Pour afficher des informations dans ce panneau, définissez des éléments tels que description et links dans la section descriptor de votre fichier application.yaml.

descriptor:
    description:
    links:
    - description:
      url:

Pour mettre à jour la section descriptor, procédez comme suit :

Dans l'éditeur Cloud Shell, remplacez le contenu du fichier application.yaml en collant ce qui suit :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    description: |-
        This application simulates a bank's payment processing network using
        [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and
        simulate transactions between accounts. Bank of Anthos was developed
        to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

Dans Cloud Shell, déployez la ressource Application :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos
Pour examiner les mises à jour, cliquez sur Afficher le panneau d'informations.

Le panneau Informations sur l'application affiche une description et une liste de documents :

Inclure le type de logiciel

La page Applications inclut un champ (Logiciel) consacré au type de logiciel dans la liste des applications. Vous pouvez personnaliser ce champ pour organiser et classer vos applications suivant vos besoins. Par exemple, vous pouvez indiquer si le logiciel est interne ou externe. Si vous avez plusieurs applications créées à partir d'un type de base partagé, vous pouvez également indiquer le type de base mis en œuvre par une application.

Pour ajouter une description personnalisée au type de logiciel, utilisez le champ type dans la section descriptor du fichier application.yaml :

 descriptor:
    type: External App

Vous pouvez afficher la valeur de type sous forme de lien hypertexte dans la console Google Cloud. Pour spécifier l'URL correspondante, utilisez la première entrée de la section links. Dans les étapes suivantes, vous allez mettre à jour la section links comme suit :

    links:
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

Dans l'éditeur Cloud Shell, remplacez le contenu de application.yaml en collant ce qui suit :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

Dans Cloud Shell, déployez la ressource Application :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page Applications.

Accéder à la page Applications

Application externe s'affiche dans le champ Logiciel :

Inclure une version de l'application

La page principale Applications inclut un champ de version. En pratique, la valeur de ce champ est mise à jour de manière automatisée afin de suivre la version réelle déployée.

Pour renseigner le champ de version, incluez le champ version sous descriptor comme dans l'exemple suivant :

  descriptor:
    type: External App
    version: "2.3.2"

Dans les étapes suivantes, vous allez ajouter un champ pour la version de l'application.

Dans l'éditeur Cloud Shell, remplacez le contenu du fichier application.yaml en collant ce qui suit :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

Dans Cloud Shell, déployez la ressource Application :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page Applications.

Accéder à la page Applications

Le champ Version de l'application Bank of Anthos s'affiche sous la forme 2.3.2 :

Ajouter des informations sur le responsable

Au cours de cette étape, vous allez ajouter du texte statique personnalisé à la section principale de la page Applications. Spécifiez ces informations dans la section info du fichier application.yaml, comme suit :

  info:
  - name: LABEL
    value: STRING

Pour inclure des valeurs statiques, vous devez fournir des détails pour LABEL et STRING dans la section info. Par exemple, vous pouvez saisir Owner pour name et John Smith pour value.

Dans l'éditeur Cloud Shell, remplacez le contenu de application.yaml en collant ce qui suit :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

  info:
  - name: Owner
    value: John Smith

Dans Cloud Shell, déployez la ressource Application :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos

La page d'informations inclut le propriétaire de l'application Bank of Anthos :

Exposer un point de terminaison d'application

En plus des valeurs statiques, vous pouvez exposer les valeurs dynamiques provenant du déploiement proprement dit. Dans les étapes suivantes, vous allez afficher l'adresse IP de l'équilibreur de charge afin que toute personne consultant la page des informations de l'application puisse accéder directement à l'application.

Pour afficher cette valeur, utilisez la spécification serviceRef. Les spécifications suivantes sont également valides :configMapKeyRef, ingressRef et secretKeyRef.

Dans la spécification serviceRef, vous incluez ces valeurs dynamiques à l'aide du type Reference. Pour ce tutoriel, la spécification de serviceRef est la suivante :

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION

Vous pouvez remplacer les valeurs suivantes :

LABEL : libellé qui décrit une instance de référence spécifique, par exemple App Frontend URL
SERVICE_NAME : le nom qui identifie le service ; par exemple : frontend
DATA_LOCATION : emplacement des données dans le service ; par exemple, status.loadBalancer.ingress[0].ip.

Les spécifications serviceRef et ingressRef acceptent également l'élément path. Si votre URL nécessite des détails liés au chemin d'accès, incluez-les dans le champ path :

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin

L'adresse IP et le chemin d'accès du point de terminaison sont concaténés, par exemple : 35.202.90.0/wp-admin.

Vous pouvez également forcer l'utilisation de HTTP ou HTTPS à l'aide du champ protocol comme suit :

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin
        protocol: HTTPS

Ces informations produisent l'URL suivante :

https://35.202.90.0/wp-admin

Dans les étapes suivantes, vous utilisez serviceRef pour exposer l'adresse IP de l'équilibreur de charge de service pour l'application Bank of Anthos :

Dans l'éditeur Cloud Shell, remplacez le contenu du fichier application.yaml par ce qui suit :

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

  info:
  - name: Owner
    value: John Smith
  - name: App Frontend URL
    type: Reference
    valueFrom:
      serviceRef:
        name: frontend
        fieldPath: status.loadBalancer.ingress[0].ip
        protocol: HTTPS

Dans Cloud Shell, déployez la ressource Application :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos

La page d'informations inclut une adresse IP de point de terminaison pour l'application Bank of Anthos :

Fournir des identifiants d'accès

Comme indiqué précédemment, vous pouvez exposer les secrets Kubernetes via la console Google Cloud à l'aide de l'élément secretKeyRef. Dans ce tutoriel, vous fournissez un nom d'utilisateur et un mot de passe à l'opérateur afin qu'il puisse se connecter à l'application.

Dans Cloud Shell, créez le secret :
```
kubectl create secret generic boa-access --from-literal=boa-user=testuser --from-literal=boa-pass=password
```
Remarque : Ce secret n'est pas utilisé dans l'application. Vous allez le créer dans ce tutoriel à des fins de démonstration.

Dans l'éditeur Cloud Shell, remplacez le contenu du fichier application.yaml en collant ce qui suit. Cette modification inclut des références au nom d'utilisateur et au mot de passe dans l'annotation secretKeyRef.

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
spec:
  selector:
    matchLabels:
     app.kubernetes.io/name: "bank-of-anthos"

  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

  descriptor:
    type: External App

    version: "2.3.2"

    description: |-
        This application simulates a bank's payment processing network using [Anthos](/anthos/).
        Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.

    links:
    - description: 'About Anthos on GCP'
      url: /anthos/
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos

  info:
  - name: Owner
    value: John Smith
  - name: App Frontend URL
    type: Reference
    valueFrom:
      serviceRef:
        name: frontend
        fieldPath: status.loadBalancer.ingress[0].ip
        protocol: HTTPS
  - name: TestUser username
    type: Reference
    valueFrom:
      secretKeyRef:
        name: boa-access
        key: boa-user

  - name: TestUser password
    type: Reference
    valueFrom:
      secretKeyRef:
        name: boa-access
        key: boa-pass

Dans Cloud Shell, déployez la ressource Application :

kubectl apply -f kubernetes-manifests/application.yaml

Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos
Cliquez sur Prévisualiser les données secrètes. Le nom d'utilisateur et le mot de passe s'affichent :

La capacité à révéler les données de secrets peut être utile pour vos équipes chargées des opérations. Cependant, la possibilité d'afficher ces secrets est régie par les autorisations d'accès IAM (Identity and Access Management) pour la page de détails de GKE. Toute personne autorisée à afficher les clusters peut également afficher les secrets. Il est donc important d'être prudent vis-à-vis des éléments que vous choisissez d'exposer.

Ajouter une icône d'application

Pour que votre application sorte du lot, vous pouvez inclure un logo affiché dans la liste des applications et sur votre page d'informations. Pour inclure un logo, vous devez spécifier l'URI de données de l'image dans l'annotation kubernetes-engine.cloud.google.com/icon.

La conversion d'une image en URI de données dépasse le cadre de ce tutoriel. Cependant, une recherche Google avec les mots clés "convertir une image en uri de données" renvoie divers utilitaires qui vous aideront à produire la chaîne de données d'une image. Étant donné que l'URI de données correspondant à l'image utilisée dans cette section est très long, il est peu pratique de l'inclure dans ce tutoriel. Vous pouvez consulter l'URI de données complet dans le fichier application.yaml complet. La chaîne de l'URI de données doit commencer par data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... et se termine par K5CYII=. Assurez-vous de ne pas inclure de guillemets finaux ni de caractères HTML.

Le fichier application.yaml complet est disponible en tant que gist pour référence.

Pour ajouter une icône, mettez à jour la section metadata de application.yaml :

Copiez le code suivant :
```
annotations:
  kubernetes-engine.cloud.google.com/icon: >-
    data:image/png;base64,DATA_URI
```
Remplacez DATA_URI par la chaîne trouvée dans le fichier application.yaml complet, référencé précédemment.

Dans l'éditeur Cloud Shell, collez le code que vous avez copié après la section labels dans la section metadata du fichier application.yaml.

Cette section de application.yaml ressemble à ceci, où DATA_URI représente la valeur de l'URI de données.

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: "bank-of-anthos"
  labels:
    app.kubernetes.io/name: "bank-of-anthos"
  annotations:
    kubernetes-engine.cloud.google.com/icon: >-
      data:image/png;base64,DATA_URI
spec:

Dans Cloud Shell, déployez la ressource d'application :
```
kubectl apply -f kubernetes-manifests/application.yaml
```
Dans la console Google Cloud, accédez à la page Applications.

Accéder à la page Applications

Un logo est affiché dans la liste des applications :
Dans la console Google Cloud, accédez à la page des détails de l'application Bank of Anthos.

Accéder aux informations de Bank of Anthos

Un logo est affiché dans l'en-tête de la page d'informations :

Nettoyer

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, vous pouvez supprimer le projet Google Cloud que vous avez créé pour ce tutoriel.

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante

Examinez d'autres exemples de fichiers application.yaml dans le dossier Kubernetes du dépôt GitHub click-to-deploy. Recherchez les autres fichiers application.yaml sous chart/<application>/templates/ pour les différentes applications ; par exemple, comme illustré dans ce fichier.
Utilisez les déploiements Marketplace pour les solutions Google de déploiement par clic pour GKE.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Centre d'architecture cloud.

Utiliser la page Applications GKE dans la console Google Cloud

Objectifs

Coûts

Avant de commencer

Préparer l'environnement

Installer les exemples d'applications

Préparer GKE

Inclure les ressources d'application

Créer la ressource Application de base

Inclure des ressources par composant

Filtrer les ressources à l'aide de sélecteurs

Appliquer des libellés à toutes les ressources à l'aide de kustomize

Ajouter des métadonnées utiles dans l'affichage

Ajouter une description et une documentation

Inclure le type de logiciel

Inclure une version de l'application

Ajouter des informations sur le responsable

Exposer un point de terminaison d'application

Fournir des identifiants d'accès

Ajouter une icône d'application

Nettoyer

Supprimer le projet

Étape suivante

Appliquer des libellés à toutes les ressources à l'aide de `kustomize`