Utiliser la page Applications GKE dans Cloud Console

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 Cloud Console.

Coûts

Ce tutoriel utilise 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é ce tutoriel, 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

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

    Accéder au sélecteur de projet

  2. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

  3. Activer les API Compute Engine and Kubernetes Engine.

    Activer les API

  4. Dans Cloud Console, 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

  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 de votre 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 Cloud Console, 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 Cloud Console :

    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 Cloud Console, 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 Cloud Console. 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 Cloud Console, 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 Cloud Console, 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 Cloud Console, 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 Cloud Console. 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 Cloud Console, 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 Cloud Console. 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 Cloud Console, 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 Cloud Console, 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 Cloud Console, 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 Cloud Console, 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 Cloud Console à 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 Cloud Console, 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 Cloud Console, 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 Cloud Console, 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.

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

  1. Dans Cloud Console, accédez à la page Gérer les ressources :

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante