Utilizzo della pagina Applicazioni GKE nella console Google Cloud

Questo tutorial descrive come utilizzare la pagina Applicazioni di Google Kubernetes Engine (GKE) nella console Google Cloud .

Quando adotti Kubernetes per molte applicazioni e risorse, può essere difficile identificare e monitorare i vari componenti correlati a un'applicazione. Quando esegui il deployment di più applicazioni in ogni spazio dei nomi, può essere difficile sapere quali risorse sono correlate a quale applicazione. Inoltre, spesso devi cercare in più posizioni la documentazione e i metadati che descrivono le applicazioni, chi sono i proprietari e come interagire con i servizi.

GKE aiuta a risolvere queste sfide con la pagina Applicazioni:

Una visualizzazione parziale della pagina Applicazioni che mostra un elenco di applicazioni insieme a varie proprietà.

La pagina Applicazioni è una risorsa indipendente all'interno della tua architettura che descrive i metadati del tuo sistema. Puoi utilizzare questa pagina per organizzare visivamente le risorse senza modificare l'architettura. Definendo i valori in un file YAML, puoi raggruppare tutte le risorse dell'applicazione e includere metadati essenziali per il tuo team operativo. La creazione, la modifica e l'eliminazione del file YAML non influiscono sulle risorse esistenti, quindi puoi lavorare immediatamente con le risorse senza rischi per il sistema.

Per dimostrare questa pagina, questo tutorial mostra come implementare la risorsa Kubernetes Application in un'applicazione e aggiungere metadati definiti dall'utente per organizzare e semplificare la gestione dell'applicazione in GKE.

Questo tutorial è rivolto agli sviluppatori che creano applicazioni da eseguire in GKE. Presuppone che tu abbia familiarità con i concetti di base di Kubernetes e che tu abbia una certa esperienza nella scrittura di file YAML delle risorse Kubernetes.

Obiettivi

  • Introduci la risorsa Applicazione Kubernetes.
  • Aggiungi la risorsa Applicazione Kubernetes a un'architettura esistente.
  • Crea e visualizza informazioni personalizzate su un'applicazione tramite la consoleGoogle Cloud .

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.

Prima di iniziare

  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

    Esegui i comandi per questo tutorial in Cloud Shell o nell'editor di Cloud Shell.

    prepara l'ambiente

    1. In Cloud Shell, imposta le variabili di ambiente per il tuo progetto:

      export PROJECT_ID=PROJECT_ID
gcloud config set core/project $PROJECT_ID
gcloud config set compute/zone us-central1-c

      Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud .

    2. Crea un cluster GKE:

      gcloud container clusters create sample-cluster

      Per questo tutorial, esegui le applicazioni in un cluster GKE predefinito.

    Installazione delle applicazioni di esempio

    In questo tutorial, simulerai più applicazioni in esecuzione nello stesso spazio dei nomi utilizzando un'applicazione di esempio Nginx di base e l'applicazione di esempio Bank of Anthos.

    1. In Cloud Shell, installa l'applicazione di esempio Nginx:

      kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/master/content/en/examples/application/web/web.yaml

      Questo comando crea una risorsa StatefulSet denominata web e un servizio denominato nginx. Nella console Google Cloud , puoi visualizzare queste risorse nelle pagine Workload e Servizi e Ingress.

    2. Clona il repository GitHub che contiene l'applicazione di esempio Bank of Anthos:

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

    3. Genera una chiave SSH e archiviala come 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'applicazione di esempio Bank of Anthos richiede una chiave SSH per essere eseguita.

    4. Esegui il deployment dell'applicazione di esempio nel tuo cluster:

      kubectl apply -f kubernetes-manifests

      Dopo qualche istante, puoi visualizzare le risorse dell'applicazione nelle seguenti pagine della console Google Cloud :

      Tieni presente quanto segue:

      • Le risorse per le applicazioni di esempio Nginx e Bank of Anthos sono mescolate.
      • Nella pagina Applicazioni non sono ancora visualizzate risorse. Compila la pagina Applicazioni nei passaggi successivi.

    Preparazione di GKE

    Le risorse visualizzate nella pagina Applicazioni sono specificate con il tipo di risorsa applicazione Kubernetes, una definizione di risorsa personalizzata (CRD) fornita dal progetto Kubernetes open source. Per impostazione predefinita, la CRD dell'applicazione non è abilitata in Kubernetes. Alcuni servizi in GKE, come Marketplace e Deployment di applicazioni, installano la CRD Application, ma se non utilizzi nessuno di questi servizi, la CRD Application non è disponibile per impostazione predefinita.

    Per installare il CRD dell'applicazione:

    1. In Cloud Shell, applica la CRD dell'applicazione una volta su ogni cluster:

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

    2. (Facoltativo) Al termine del comando, visualizza il CRD dell'applicazione sul cluster:

      kubectl get crd

      L'output seguente è un elenco di CRD installate, tra cui 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

    Inclusione delle risorse dell'applicazione

    Ora che la CRD dell'applicazione è disponibile nel cluster, il passaggio successivo consiste nel creare ed eseguire il deployment di un'istanza della risorsa Application.

    Poiché la risorsa Application è una risorsa Kubernetes, ha una struttura simile ad altre risorse Kubernetes, inclusi campi e opzioni per apiVersion, kind, metadata e spec:

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

    Nelle sezioni seguenti, lavorerai con vari campi e opzioni disponibili nella risorsa Applicazione.

    Crea la risorsa applicazione di base

    Puoi aggiungere la risorsa Applicazione a qualsiasi insieme di risorse esistente. In questo tutorial, inizi con una risorsa vuota e compili ogni sezione.

    1. In Cloud Shell, crea e modifica un file application.yaml nella directory kubernetes-manifests:

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

      L'editor di Cloud Shell si apre e viene visualizzato un file vuoto.

    2. Incolla le seguenti righe per definire la prima applicazione:

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

    3. Nella barra dei menu di Cloud Shell, fai clic su Apri terminale.

    4. In Cloud Shell, applica la risorsa:

      kubectl apply -f kubernetes-manifests/application.yaml

    5. Nella console Google Cloud , vai alla pagina Applicazioni.

      Vai a Applicazioni

      La pagina Applicazioni mostra le risorse che hai aggiunto:

      L'applicazione Bank of Anthos è inclusa nell'elenco delle applicazioni.

    Includi risorse per componente

    La pagina Applicazioni mostra l'applicazione Bank of Anthos. Quando fai clic su bank-of-anthos nel campo Nome, visualizzi le informazioni di base sull'applicazione:

    I dettagli dell'applicazione includono cluster, spazio dei nomi e data di creazione.

    Puoi aggiungere vari tipi di componenti da visualizzare nella consoleGoogle Cloud . Ad esempio, per mostrare servizi, deployment e StatefulSet, modifica la sezione componentKinds della definizione application.yaml, ad esempio nel seguente modo:

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

    Nei passaggi successivi, aggiungi questi componenti alla definizione della risorsa Bank of Anthos:

    1. Nella barra dei menu di Cloud Shell, fai clic su Apri editor.

    2. Nell'editor di Cloud Shell, sovrascrivi i contenuti del file kubernetes-manifests/application.yaml incollando quanto segue:

      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'aggiunta della sezione spec aggiunge Service, Deployment e StatefulSet alla definizione dell'applicazione.

    3. In Cloud Shell, applica la risorsa:

      kubectl apply -f kubernetes-manifests/application.yaml

    4. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

      Vengono visualizzati i componenti di un determinato tipo:

      L'elenco dei dettagli include tipi di componenti come Servizio e Deployment.

    Filtrare le risorse con i selettori

    A questo punto del tutorial, l'elenco dei componenti include tutte le risorse per entrambe le applicazioni di esempio per l'insieme definito di componenti dell'intero spazio dei nomi. Ad esempio, il seguente diagramma mostra il servizio nginx dell'applicazione di esempio Nginx e il deployment transactionhistory dell'applicazione di esempio Bank of Anthos:

    L'elenco dei componenti viene generato da tutte le applicazioni nello spazio dei nomi.

    Per assicurarti che vengano visualizzate solo le risorse per un'applicazione, ad esempio per l'applicazione Bank of Anthos, puoi utilizzare i selettori per identificare risorse specifiche. Per vedere come funzionano i selettori, aggiungi un'etichetta alla risorsa nei seguenti passaggi:

    1. In Cloud Shell, apri il file frontend.yaml:

      edit kubernetes-manifests/frontend.yaml

    2. Nell'editor di Cloud Shell, incolla la seguente voce label dopo la riga 18:

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

      La sezione metadata ha il seguente aspetto:

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

      Il file application.yaml completato ha il seguente aspetto:

      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. In Cloud Shell, applica le risorse:

      kubectl apply -f kubernetes-manifests/

    4. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

      Viene visualizzata solo la risorsa che corrisponde a un'etichetta specifica:

      L'elenco dei componenti mostra la risorsa di deployment.

    Applica le etichette a tutte le risorse con kustomize

    L'applicazione manuale di etichette a ogni risorsa di un'applicazione può essere noiosa. I passaggi seguenti mostrano come utilizzare kustomize per aggiungere in modo efficiente etichette a tutte le risorse:

    1. In Cloud Shell, scarica kustomize:

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

    2. Crea e modifica un file kustomization.yaml:

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

    3. Nell'editor di Cloud Shell, aggiungi le seguenti righe a 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"

      In questa definizione di kustomization.yaml, specifica a quali risorse applicare le modifiche e quali modifiche apportare. In questo caso, specifichi che tutte le risorse devono avere un'etichetta comune di app.kubernetes.io/name: "bank-of-anthos".

    4. In Cloud Shell, elimina le risorse precedenti:

      kubectl delete -f kubernetes-manifests/

      È necessario eliminare le risorse precedenti prima di applicare le nuove risorse specificate in kustomization.yaml.

    5. Applica le risorse utilizzando il flag kustomize anziché il flag file:

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

    6. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

      La pagina dei dettagli mostra le risorse per l'applicazione di esempio Bank of Anthos e nessuna risorsa dell'applicazione di esempio Nginx:

      Vengono visualizzati solo i componenti di Bank of Anthos, come StatefulSet.

    Aggiunta di metadati utili nella visualizzazione

    Puoi visualizzare i metadati personalizzati per un'applicazione nella consoleGoogle Cloud . Puoi includere informazioni su cosa fa l'applicazione, chi ne è il proprietario, dove trovare maggiori informazioni e come accedere. Questo tipo di informazioni è utile per vari casi d'uso, ad esempio se gestisci più applicazioni all'interno della tua organizzazione.

    Le sezioni seguenti descrivono alcuni dei metadati che puoi aggiungere.

    Aggiungere una descrizione e la documentazione

    Puoi aggiungere una descrizione e link che vengono visualizzati nel riquadro Informazioni sull'applicazione. Per accedere a questo riquadro dalla pagina Dettagli, fai clic su Mostra riquadro informazioni.

    Per visualizzare le informazioni in questo riquadro, definisci elementi come description e links nella sezione descriptor del file application.yaml.

    descriptor:
    description:
    links:
    - description:
      url:

    Per aggiornare la sezione descriptor:

    1. Nell'editor di Cloud Shell, sovrascrivi i contenuti del file application.yaml incollando quanto segue:

      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. In Cloud Shell, esegui il deployment della risorsa Application:

      kubectl apply -f kubernetes-manifests/application.yaml

    3. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

    4. Per esaminare gli aggiornamenti, fai clic su Mostra riquadro informazioni.

      Il riquadro Informazioni sull'applicazione mostra una descrizione e un elenco di documenti:

      I documenti nell'elenco sono formattati come link ipertestuali.

    Includi il tipo di software

    La pagina Applicazioni include un campo (Software) per il tipo di software nell'elenco delle applicazioni. Puoi personalizzare questo campo per organizzare e classificare le tue applicazioni in base alle tue esigenze. Ad esempio, potresti indicare se il software è interno o esterno. In alternativa, se hai più app create da un tipo di base condiviso, puoi indicare quale tipo di base implementa un'applicazione.

    Per aggiungere una descrizione personalizzata al tipo di software, utilizza il campo type nella sezione descriptor del file application.yaml:

     descriptor:
    type: External App

    Puoi visualizzare il valore di type come link ipertestuale nella consoleGoogle Cloud . Specifica l'URL dell'iperlink utilizzando la prima voce della sezione links. Nei passaggi seguenti, aggiorna la sezione links come segue:

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

    1. Nell'editor di Cloud Shell, sovrascrivi i contenuti di application.yaml incollando quanto segue:

      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. In Cloud Shell, esegui il deployment della risorsa Application:

      kubectl apply -f kubernetes-manifests/application.yaml

    3. Nella console Google Cloud , vai alla pagina Applicazioni.

      Vai a Applicazioni

      App esterna viene visualizzato nel campo Software:

      Il tipo di software App esterna è formattato come link ipertestuale.

    Includere una versione dell'applicazione

    La pagina principale Applicazioni include un campo per la versione. In pratica, il valore di questo campo viene aggiornato in modo programmatico per fare riferimento alla versione effettiva di cui è stato eseguito il deployment.

    Per compilare il campo della versione, includi il campo version in descriptor, come nel seguente esempio:

      descriptor:
    type: External App
    version: "2.3.2"

    Nei passaggi successivi, aggiungi un campo per la versione dell'applicazione.

    1. Nell'editor di Cloud Shell, sovrascrivi i contenuti del file application.yaml incollando quanto segue:

      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. In Cloud Shell, esegui il deployment della risorsa Application:

      kubectl apply -f kubernetes-manifests/application.yaml

    3. Nella console Google Cloud , vai alla pagina Applicazioni.

      Vai a Applicazioni

      Il campo Versione per l'applicazione Bank of Anthos viene visualizzato come 2.3.2:

      I dettagli dell'applicazione includono i campi relativi al tipo e alla versione del software.

    Aggiungere i dettagli del manutentore

    In questo passaggio, aggiungi testo statico personalizzato alla sezione principale della pagina Applicazioni. Specifica questi dettagli nella sezione info del file application.yaml nel seguente modo:

      info:
  - name: LABEL
    value: STRING

    Per includere valori statici, fornisci i dettagli per LABEL e STRING nella sezione info. Ad esempio, potresti inserire Owner per name e John Smith per value.

    1. Nell'editor di Cloud Shell, sovrascrivi i contenuti di application.yaml incollando quanto segue:

      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. In Cloud Shell, esegui il deployment della risorsa Application:

      kubectl apply -f kubernetes-manifests/application.yaml

    3. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

      La pagina dei dettagli include un proprietario per l'applicazione Bank of Anthos:

      Mario Rossi è indicato come proprietario.

    Esporre un endpoint dell'applicazione

    Oltre ai valori statici, puoi esporre i valori dinamici della deployment. Nei passaggi seguenti, viene visualizzato l'indirizzo IP del bilanciatore del carico in modo che chiunque visualizzi la pagina dei dettagli dell'applicazione possa accedervi direttamente.

    Per visualizzare questo valore, utilizza la specifica serviceRef. Altre specifiche valide includono configMapKeyRef, ingressRef, e secretKeyRef.

    Nella specifica serviceRef, includi questi valori dinamici utilizzando il tipo Reference. Per questo tutorial, la specifica per serviceRef è la seguente:

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

    Puoi sostituire i seguenti valori:

    • LABEL: un'etichetta che descrive un'istanza di riferimento specifica, ad esempio App Frontend URL
    • SERVICE_NAME: il nome che identifica il servizio, ad esempio frontend
    • DATA_LOCATION: la posizione dei dati nel Servizio, ad esempio status.loadBalancer.ingress[0].ip

    Le specifiche serviceRef e ingressRef supportano anche l'elemento path. Se il tuo URL richiede dettagli relativi al percorso, includili nel campo path:

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

    L'indirizzo IP e il percorso dell'endpoint vengono concatenati, ad esempio 35.202.90.0/wp-admin.

    Puoi anche forzare l'utilizzo di HTTP o HTTPS utilizzando il campo protocol come segue:

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

    Questi dettagli producono il seguente URL:

    https://35.202.90.0/wp-admin

    Nei passaggi seguenti, utilizzi serviceRef per esporre l'indirizzo IP del bilanciatore del carico del servizio per l'applicazione Bank of Anthos:

    1. Nell'editor di Cloud Shell, sovrascrivi i contenuti del file application.yaml con quanto segue:

      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. In Cloud Shell, esegui il deployment della risorsa Application:

      kubectl apply -f kubernetes-manifests/application.yaml

    3. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

      La pagina dei dettagli include un indirizzo IP dell'endpoint per l'applicazione Bank of Anthos:

      L'indirizzo IP è etichettato come URL frontend app.

    Fornisci le credenziali di accesso

    Come accennato in precedenza, puoi esporre i secret di Kubernetes tramite la consoleGoogle Cloud utilizzando l'elemento secretKeyRef. In questo tutorial, fornisci un nome utente e una password all'operatore in modo che possa accedere all'applicazione.

    1. In Cloud Shell, crea il secret:

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

    2. Nell'editor di Cloud Shell, sovrascrivi i contenuti del file application.yaml incollando quanto segue. Questo aggiornamento include riferimenti al nome utente e alla password nell'annotazione 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. In Cloud Shell, esegui il deployment della risorsa Application:

      kubectl apply -f kubernetes-manifests/application.yaml

    4. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

    5. Fai clic su anteprima dei dati secret. Il nome utente e la password vengono visualizzati:

      I dettagli dell'applicazione includono link per accedere alle credenziali.

    La possibilità di rivelare i dati dei segreti può essere una funzionalità utile per i team operativi. Tuttavia, la possibilità di visualizzare questi secret è regolata dalle autorizzazioni di accesso Identity and Access Management (IAM) per la pagina dei dettagli di GKE. Chiunque abbia le autorizzazioni per visualizzare i cluster può visualizzare anche i secret, quindi è importante valutare attentamente ciò che esponi.

    Aggiungere un'icona dell'applicazione

    Per far risaltare la tua applicazione, puoi includere un logo visualizzato nell'elenco delle applicazioni e nella pagina dei dettagli. Per includere un logo, specifica l'URI di dati dell'immagine nell'annotazione kubernetes-engine.cloud.google.com/icon.

    La conversione di un'immagine in un URI dati non rientra nell'ambito di questo tutorial. Tuttavia, una ricerca su Google con la query "converti immagine in URI dati" restituisce varie utilità per aiutarti a produrre la stringa di dati da un'immagine. Poiché l'URI dei dati per l'immagine utilizzata in questa sezione è molto lungo, è poco pratico includerlo nel tutorial. L'URI completo dei dati è visibile nel file application.yaml completato. La stringa URI dei dati deve iniziare così: data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... e terminare con K5CYII=. Assicurati di non includere virgolette finali o caratteri HTML.

    Il file application.yaml completo è disponibile come gist per riferimento.

    Per aggiungere un'icona, aggiorna la sezione metadata di application.yaml:

    1. Copia il seguente codice:

      annotations:
  kubernetes-engine.cloud.google.com/icon: >-
    data:image/png;base64,DATA_URI

      Sostituisci DATA_URI con la stringa trovata nel file application.yaml completato a cui viene fatto riferimento in precedenza.

    2. Nell'editor di Cloud Shell, incolla il codice che hai copiato dopo la sezione labels nella sezione metadata di application.yaml.

      Questa sezione di application.yaml ha un aspetto simile al seguente, dove DATA_URI rappresenta il valore dell'URI dati.

      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. In Cloud Shell, esegui il deployment della risorsa dell'applicazione:

      kubectl apply -f kubernetes-manifests/application.yaml

    4. Nella console Google Cloud , vai alla pagina Applicazioni.

      Vai a Applicazioni

      Nell'elenco delle applicazioni viene visualizzato un logo:

      Un logo viene visualizzato accanto al nome dell'applicazione nell'elenco delle applicazioni.

    5. Nella console Google Cloud , vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

      Vai ai dettagli di Bank of Anthos

      Un logo viene visualizzato nell'intestazione della pagina dei dettagli:

      Un logo viene mostrato nella parte superiore dell'elenco dei dettagli dell'applicazione.

    Esegui la pulizia

    Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi eliminare il progetto Google Cloud che hai creato per il tutorial.

    Elimina il progetto

    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.

    Passaggi successivi