Utilizzo della pagina Applicazioni GKE nella console

Questo tutorial descrive come utilizzare la pagina Google Kubernetes Engine (GKE) Applicazioni in Google Cloud Console.

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, devi cercare spesso in più posizioni documentazione e metadati che descrivono quali sono 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 dell'architettura che descrive i metadati del tuo sistema. Puoi utilizzare questa pagina per organizzare visivamente le risorse senza modificare l'architettura. Con la definizione dei valori in un file YAML, puoi raggruppare tutte le risorse delle tue applicazioni e includere metadati essenziali per il tuo team operativo. La creazione, la modifica e l'eliminazione del file YAML non influisce sulle risorse esistenti, quindi puoi lavorare immediatamente con le risorse senza rischi per il tuo sistema.

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

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

Obiettivi

  • Introduci la risorsa dell'applicazione Kubernetes.
  • Aggiungere la risorsa dell'applicazione Kubernetes a un'architettura esistente.
  • Crea e visualizza informazioni personalizzate su un'applicazione attraverso la console.

Costi

Questo tutorial utilizza 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 possono beneficiare di una prova gratuita.

Al termine di questo tutorial, puoi evitare una fatturazione continua eliminando le risorse che hai creato. Per scoprire di più, vedi Pulizia.

Prima di iniziare

  1. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  2. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  3. Abilita le API Compute Engine and Kubernetes Engine.

    Abilita le API

  4. Nella console, attiva Cloud Shell.

    Attiva Cloud Shell

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

Preparazione dell'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 progetto di Google Cloud.

  2. Crea un cluster GKE:

    gcloud container clusters create sample-cluster

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

Installazione delle applicazioni di esempio

In questo tutorial, puoi simulare 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 chiamato nginx. Nella console, puoi visualizzare queste risorse nelle pagine Carichi di lavoro e Servizi e Ingress di GKE.

  2. Clona il repository GitHub contenente 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 l'esecuzione.

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

    kubectl apply -f kubernetes-manifests

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

    Tieni presente quanto segue:

    • Le risorse per le applicazioni di esempio Nginx e Bank of Anthos sono miste.
    • Nessuna risorsa viene ancora visualizzata nella pagina Applicazioni. Puoi completare la pagina Applicazioni nei passaggi successivi.

Preparazione di GKE

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

Per installare il CRD dell'applicazione:

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

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

  2. (Facoltativo) Una volta completato il comando, visualizza il CRD dell'applicazione sul cluster:

    kubectl get crd

    Il seguente output è un elenco di CRD installati, inclusi 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

Include risorse dell'applicazione

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

Dato che la risorsa Applicazione è una risorsa Kubernetes, ha una struttura simile ad altre risorse Kubernetes, inclusi campi e opzioni di apiVersion, kind, metadata e spec:

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

Le sezioni seguenti descrivono i vari campi e le opzioni disponibili nella risorsa dell'applicazione.

Crea la risorsa base dell'applicazione

Puoi aggiungere la risorsa dell'applicazione a qualsiasi insieme di risorse esistente. In questo tutorial, inizierai con una risorsa vuota e compila ciascuna 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 righe seguenti per definire la tua 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, vai alla pagina Applicazioni.

    Vai ad Applicazioni

    Nella pagina Applicazioni vengono visualizzate le risorse aggiunte:

    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 Name (Nome), vengono visualizzate 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 console. Ad esempio, per visualizzare Servizi, Deployment e StatefulSet, modifica la sezione componentKinds della definizione di application.yaml, come segue:

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

Nei passaggi seguenti aggiungi i componenti alla definizione di 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, 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 di dettagli include tipi di componenti come Service e Deployment.

Filtra risorse con selettori

A questo punto del tutorial, l'elenco dei componenti include tutte le risorse per entrambe le applicazioni di esempio per il set di componenti definito dell'intero spazio dei nomi. Ad esempio, il seguente diagramma mostra il servizio nginx dall'applicazione di esempio Nginx e il deployment transactionhistory dall'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 di 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 tua 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, vai alla pagina dei dettagli dell'applicazione Bank of Anthos.

    Vai ai dettagli di Bank of Anthos

    Viene visualizzata l'unica risorsa che corrisponde a un'etichetta specifica:

    L'elenco dei componenti mostra la risorsa Deployment.

Applica le etichette a tutte le risorse con kustomize

L'applicazione manuale delle etichette a ogni risorsa in un'applicazione può essere noiosa. I seguenti passaggi spiegano come utilizzare kustomize per aggiungere etichette in modo efficiente 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 kustomization.yaml, devi specificare a quali risorse applicare le modifiche e quali apportare. In questo caso, specifica che tutte le risorse dovrebbero 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/

    Prima di applicare le nuove risorse specificate in kustomization.yaml, devi eliminare le risorse precedenti.

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

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

  6. Nella console, 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 Bank of Anthos, come lo StatefulSet.

Aggiungere metadati utili sul display

Puoi visualizzare i metadati personalizzati per un'applicazione nella console. Potresti includere cosa fa l'applicazione, chi è il proprietario, dove trovare ulteriori informazioni e come accedervi. Questo tipo di informazione è utile per vari casi d'uso, ad esempio se utilizzi più applicazioni all'interno della tua organizzazione.

Di seguito sono descritti alcuni dei metadati che è possibile aggiungere.

Aggiungi una descrizione e una documentazione

Puoi aggiungere una descrizione e i link che vengono visualizzati nel riquadro Informazioni 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, procedi nel seguente modo:

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

    kubectl apply -f kubernetes-manifests/application.yaml

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

    Vai ai dettagli di Bank of Anthos

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

    Il riquadro Informazioni applicazione contiene 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 che il software è interno o esterno. Se invece hai più app create con un tipo di base condiviso, potresti indicare il tipo di base implementato da 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 console. Devi specificare l'URL per il link ipertestuale utilizzando il primo punto della sezione links. Nei passaggi seguenti, aggiorni la sezione links nel seguente modo:

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

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console, vai alla pagina Applicazioni.

    Vai ad Applicazioni

    Nel campo Software viene visualizzata l'app esterna:

    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 per questo campo viene aggiornato in modo programmatico per fare riferimento alla versione effettiva di cui è stato eseguito il deployment.

Per completare il campo della versione, includi il campo version in descriptor come nell'esempio seguente:

  descriptor:
    type: External App
    version: "2.3.2"

Nei passaggi seguenti 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 applicazione:

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console, vai alla pagina Applicazioni.

    Vai ad Applicazioni

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

    I dettagli dell'applicazione includono il campo relativo al tipo di software e ai campi di versione.

Aggiungi dettagli sul gestore

In questo passaggio devi aggiungere testo statico personalizzato alla sezione principale della pagina Applicazioni. Specifica questi dettagli nella sezione info del file application.yaml come segue:

  info:
  - name: LABEL
    value: STRING

Per includere valori statici, devi fornire i dettagli per LABEL e STRING nella sezione info. Ad esempio, puoi 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 applicazione:

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console, 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 valori dinamici dal deployment stesso. Nei passaggi seguenti, puoi visualizzare l'indirizzo IP del bilanciatore del carico in modo che chiunque possa visualizzare la pagina dei dettagli dell'applicazione possa accedere direttamente all'applicazione.

Per visualizzare questo valore, utilizza la specifica serviceRef. Altre specifiche valide sono: 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: etichetta che descrive un'istanza di riferimento specifica, ad esempio App Frontend URL
  • SERVICE_NAME: il nome che identifica il Service$mdash, 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 l'URL richiede dettagli relativi al percorso, includi questi dettagli 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 sono concatenati, ad esempio 35.202.90.0/wp-admin.

Puoi anche forzare l'utilizzo del protocollo 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 generano il seguente URL:

https://35.202.90.0/wp-admin

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

  1. Nell'editor di Cloud Shell, sovrascrivi i contenuti del file application.yaml con il seguente testo:

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

    kubectl apply -f kubernetes-manifests/application.yaml

  3. Nella console, 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 endpoint per l'applicazione Bank of Anthos:

    L'indirizzo IP è indicato come App Frontend URL.

Fornisci le credenziali di accesso

Come accennato sopra, puoi esporre i Secret di Kubernetes attraverso la console tramite 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 applicazione:

    kubectl apply -f kubernetes-manifests/application.yaml

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

    Vai ai dettagli di Bank of Anthos

  5. Fai clic su Visualizza l'anteprima dei dati segreti. Vengono visualizzati nome utente e password:

    I dettagli dell'applicazione includono link per l'accesso alle credenziali.

La possibilità di rivelare dati segreti può essere una funzionalità utile per i tuoi team operativi. Tuttavia, la possibilità di visualizzare questi secret è regolata dalle autorizzazioni di accesso a IAM (Identity and Access Management) per la pagina dei dettagli di GKE. Chiunque disponga delle autorizzazioni per visualizzare i cluster può visualizzare i secret, pertanto è importante valutare con attenzione cosa esporre.

Aggiungi un'icona dell'applicazione

Per mettere in risalto la tua applicazione, puoi includere un logo visualizzato nell'elenco delle applicazioni e nella pagina dei dettagli. Per includere un logo, devi specificare l'URI dei dati nell'immagine nell'annotazione kubernetes-engine.cloud.google.com/icon.

La conversione di un'immagine in un URI di dati non rientra nell'ambito di questo tutorial. Tuttavia, una ricerca su Google "converti l'immagine in 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 è così lungo, non è utile includerlo nel tutorial. L'URI completo dei dati è visibile nel file application.yaml completato. La stringa URI dei dati deve iniziare in questo modo: data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... termina con K5CYII=. Assicurati di non includere virgolette finali o caratteri HTML.

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

Per aggiungere un'icona, aggiorni 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 presente 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.

    La sezione di application.yaml è simile alla seguente, dove DATA_URI rappresenta il valore dell'URI dei 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, vai alla pagina Applicazioni.

    Vai ad Applicazioni

    Nell'elenco delle applicazioni viene visualizzato un logo:

    Nell'elenco delle applicazioni viene visualizzato un logo accanto al nome dell'applicazione.

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

    Vai ai dettagli di Bank of Anthos

    Nell'intestazione della pagina dei dettagli viene visualizzato un logo:

    Nella parte superiore dell'elenco dei dettagli dell'applicazione viene visualizzato un logo.

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 questo tutorial.

Elimina il progetto

  1. Nella console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto da eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi