Utiliser la page Applications GKE dans la console Google Cloud

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

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 en utilisant la consoleGoogle Cloud .

Coûts

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

Vous pouvez obtenir 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, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Verify that billing is enabled for your Google Cloud project.

  3. Enable the Compute Engine and Kubernetes Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  4. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

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

    Préparer l'environnement

    1. 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 du projet Google Cloud .

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

    1. 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 pages GKE Charges de travail et Services et entrées.

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

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

    4. 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  :

      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 :

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

    2. (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.

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

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

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

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

    4. Dans Cloud Shell, appliquez la ressource :

      kubectl apply -f kubernetes-manifests/application.yaml

    5. 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 :

      L'application Bank of Anthos est incluse dans la liste des applications.

    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 consoleGoogle 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 :

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

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

    3. Dans Cloud Shell, appliquez la ressource :

      kubectl apply -f kubernetes-manifests/application.yaml

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

      Accéder aux informations de Bank of Anthos

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

      La liste des informations inclut les types de composants tels que le service et le déploiement.

    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 :

    1. Dans Cloud Shell, ouvrez le fichier frontend.yaml :

      edit kubernetes-manifests/frontend.yaml

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

    3. Dans Cloud Shell, appliquez les ressources :

      kubectl apply -f kubernetes-manifests/

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

      Accéder aux informations de Bank of Anthos

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

      La liste des composants affiche la ressource de déploiement.

    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 :

    1. Dans Cloud Shell, téléchargez kustomize :

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

    2. Créez et modifiez un fichier kustomization.yaml :

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

    3. 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".

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

    5. Appliquez les ressources à l'aide de l'option kustomize au lieu de l'option file :

      ./kustomize build kubernetes-manifests/ | kubectl apply -f -

    6. Dans la console Google Cloud , accédez à la page d'informations 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 :

      Seuls les composants Bank of Anthos, tels que les objets StatefulSet, sont affichés.

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

    Vous pouvez afficher des métadonnées personnalisées pour une application dans la consoleGoogle 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 :

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

    2. Dans Cloud Shell, déployez la ressource Application :

      kubectl apply -f kubernetes-manifests/application.yaml

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

      Accéder aux informations de Bank of Anthos

    4. 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 :

      Les documents de la liste sont mis en forme en tant que liens hypertextes.

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

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

    2. Dans Cloud Shell, déployez la ressource Application :

      kubectl apply -f kubernetes-manifests/application.yaml

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

      Accéder à la page Applications

      Application externe s'affiche dans le champ Logiciel :

      Le type de logiciel "Application externe" est mis en forme en tant que lien hypertexte.

    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.

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

    2. Dans Cloud Shell, déployez la ressource Application :

      kubectl apply -f kubernetes-manifests/application.yaml

    3. 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 :

      Les informations relatives à l'application incluent les champs de type de logiciel et de version.

    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.

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

    2. Dans Cloud Shell, déployez la ressource Application :

      kubectl apply -f kubernetes-manifests/application.yaml

    3. Dans la console Google Cloud , accédez à la page d'informations 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 :

      John Smith est désigné comme le propriétaire.

    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 :

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

    2. Dans Cloud Shell, déployez la ressource Application :

      kubectl apply -f kubernetes-manifests/application.yaml

    3. Dans la console Google Cloud , accédez à la page d'informations 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 :

      L'adresse IP est intitulée "URL d'interface d'application".

    Fournir des identifiants d'accès

    Comme indiqué précédemment, vous pouvez exposer les secrets Kubernetes via la consoleGoogle 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.

    1. Dans Cloud Shell, créez le secret :

      kubectl create secret generic boa-access --from-literal=boa-user=testuser --from-literal=boa-pass=password

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

    3. Dans Cloud Shell, déployez la ressource Application :

      kubectl apply -f kubernetes-manifests/application.yaml

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

      Accéder aux informations de Bank of Anthos

    5. Cliquez sur Prévisualiser les données secrètes. Le nom d'utilisateur et le mot de passe s'affichent :

      Les informations de l'application incluent des liens pour accéder aux identifiants.

    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 :

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

    2. 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:

    3. Dans Cloud Shell, déployez la ressource d'application :

      kubectl apply -f kubernetes-manifests/application.yaml

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

      Accéder à la page Applications

      Un logo est affiché dans la liste des applications :

      Un logo s'affiche à côté du nom de l'application dans la liste des applications.

    5. Dans la console Google Cloud , accédez à la page d'informations 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 :

      Un logo est affiché en haut de la liste d'informations de l'application.

    Effectuer un nettoyage

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

    Supprimer le projet

    1. In the Google Cloud console, go to the Manage resources page.

      Go to Manage resources

    2. In the project list, select the project that you want to delete, and then click Delete.
    3. In the dialog, type the project ID, and then click Shut down to delete the project.

    Étapes suivantes