Configurazione di un proxy Pub/Sub per i client mobile su GKE

Creazione di un argomento Pub/Sub

• In Cloud Shell, crea un argomento Pub/Sub in cui pubblicare messaggi:

  gcloud pubsub topics create $TOPIC
  

Crea un cluster GKE

1. In Cloud Shell, crea un cluster GKE:

   gcloud container clusters create $CLUSTER \
       --zone $ZONE \
       --scopes "https://www.googleapis.com/auth/cloud-platform"
   

2. Recupera le credenziali per il cluster in esecuzione:

   gcloud container clusters get-credentials $CLUSTER \
       --zone $ZONE \
       --project $PROJECT
   

Creazione di un'immagine container in corso…

1. In Cloud Shell, clona il repository di codice:

   git clone https://github.com/GoogleCloudPlatform/solutions-pubsub-proxy-rest
   

2. Utilizza Cloud Build per creare un'immagine container dall'origine, quindi salvala in Container Registry:

   cd solutions-pubsub-proxy-rest && \
       gcloud builds submit --tag gcr.io/$PROJECT/pubsub-proxy:v1
   

Creazione di un indirizzo IP esterno statico

1. In Cloud Shell, crea un indirizzo IP esterno statico che viene successivamente assegnato al bilanciatore del carico del proxy Pub/Sub:

   gcloud compute addresses create service-ip --region $REGION
   

2. Archivia l'indirizzo IP statico in una variabile di ambiente, PROXY_IP:

   PROXY_IP=$(gcloud compute addresses describe service-ip \
       --region $REGION --format='value(address)')
   

Deployment di endpoint

Il proxy Pub/Sub utilizza gli endpoint per autenticare le richieste degli utenti. Endpoints utilizza Extensible Service Proxy (ESP) per fornire funzionalità di gestione delle API come autenticazione, monitoring, tracciamento e gestione del ciclo di vita delle API. Questo tutorial utilizza Endpoints solo per autenticare le richieste in entrata al proxy Pub/Sub.

In questo tutorial, eseguirai il deployment di ESP come sidecar con il proxy Pub/Sub. ESP intercetta e autentica le richieste in entrata prima di inoltrarle al proxy Pub/Sub.

1. In Cloud Shell, sostituisci il segnaposto [PROJECT_ID] con l'ID del tuo progetto Google Cloud nel file openapi.yaml:

   sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" openapi.yaml
   

2. Nel file manifest OpenAPI, sostituisci il segnaposto [IP_ADDRESS] con il valore di PROXY_IP:

   sed -i -e "s/\[IP_ADDRESS\]/$PROXY_IP/g" openapi.yaml
   

3. Esegui il deployment della definizione del servizio OpenAPI su Endpoints:

   gcloud endpoints services deploy openapi.yaml
   

   Il comando precedente crea quanto segue:

   • Un servizio gestito con il nome specificato nel campo host del file openapi.yaml (pubtest.endpoints.project-id.cloud.goog), dove project-id è l'ID del progetto Google Cloud.
   • Un record A DNS che utilizza il nome del servizio e la mappatura dell'indirizzo IP del bilanciatore del carico proxy Pub/Sub definita nell'estensione x-google-endpoints del file openapi.yaml.

   Durante il deployment, viene visualizzato un avviso che puoi ignorare perché questo tutorial utilizza i token ID OIDC per l'autenticazione anziché le chiavi API.

   WARNING: openapi.yaml: Operation 'post' in path '/publish': Operation does
   not require an API key; callers may invoke the method without specifying an
   associated API-consuming project. To enable API key all the
   SecurityRequirement Objects
   (https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#security-requirement-object)
   inside security definition must reference at least one SecurityDefinition
   of type : 'apiKey'.
   

4. Verifica che il deployment del servizio sia stato eseguito correttamente:

   gcloud endpoints services describe ${ENDPOINTS_SERVICE}
   

   L'output è simile al seguente:

   [...]
   producerProjectId: project-id
   serviceConfig:
     documentation:
       summary: Pub/Sub proxy exposed as an Endpoint API
   [...]
     name: pubtest.endpoints.project-id.cloud.goog
     title: PubSub Proxy
     usage: {}
   serviceName: pubtest.endpoints.project-id.cloud.goog
   

   Nell'output:

   • project-id: l'ID del tuo progetto Google Cloud.

Deployment di un proxy

1. In Cloud Shell, genera un certificato SSL autofirmato per consentire le connessioni HTTPS al proxy.

   openssl req -x509 -nodes -days 365 \
       -newkey rsa:2048 -keyout ./nginx.key \
       -out ./nginx.crt \
       -subj "/CN=${ENDPOINTS_SERVICE}"
   

2. Crea un secret Kubernetes utilizzando il certificato SSL e la chiave privata:

   kubectl create secret generic nginx-ssl \
       --from-file=./nginx.crt \
       --from-file=./nginx.key
   

3. Sostituisci il segnaposto [PROJECT_ID] nel file manifest di deployment con il tuo ID progetto Google Cloud:

   sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" kube/deployment.yaml
   

4. Sostituisci il segnaposto [IP_ADDRESS] nel file manifest del servizio con il valore PROXY_IP:

   sed -i -e "s/\[IP_ADDRESS\]/$PROXY_IP/g" kube/service.yaml
   

5. Esegui il deployment del proxy:

   kubectl apply -f kube/
   

6. Verifica che il deployment sia riuscito:

   kubectl rollout status deployment/pubsub-proxy
   

   L'output è simile al seguente:

   [...]
   deployment "pubsub-proxy" successfully rolled out
   

7. Assicurati che due container (proxy EP e Pub/Sub) siano in esecuzione nel pod:

   kubectl get pods $(kubectl get pod \
       -l app=pubsub-proxy \
       -o jsonpath="{.items[0].metadata.name}") \
       -o jsonpath={.spec.containers[*].name}
   

   L'output è simile al seguente:

   esp  pubsub-proxy
   

8. Controlla che il valore di EXTERNAL-IP passi da <pending> all'indirizzo IP esterno statico che hai creato in precedenza:

   kubectl get svc pubsub-proxy -w
   

   L'output è simile al seguente:

   NAME          TYPE          CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
   pubsub-proxy  LoadBalancer  10.7.247.212  <pending>     443:31104/TCP  6m32s
   pubsub-proxy  LoadBalancer  10.7.247.212  <PROXY_IP>    443:31104/TCP  6m5s
   

   Per interrompere la visione, premi CTRL+C.

   Una volta eseguito il deployment del proxy Pub/Sub, il proxy viene esposto all'indirizzo https://${ENDPOINTS_SERVICE}/publish. La propagazione della nuova configurazione DNS potrebbe richiedere alcuni minuti.

9. Verifica la configurazione DNS:

   watch nslookup ${ENDPOINTS_SERVICE}
   

   L'output è simile al seguente:

   Server:   169.254.169.254
   Address:  169.254.169.254#53
   
   Non-authoritative answer:
   Name: pubtest.endpoints.project-id.cloud.goog
   Address: gke-load-balancer-ip
   

   Nell'output:

   • gke-load-balancer-ip: l'indirizzo IP del bilanciatore del carico GKE (IP proxy).

   Per interrompere la visione, premi CTRL+C.

Se uno dei passaggi precedenti genera un errore, consulta la procedura per la risoluzione dei problemi.

Generazione di un token di autenticazione

La seguente procedura per la generazione di un token di autenticazione è da intendersi come esempio. Per il tuo ambiente di produzione, hai bisogno di un modo per consentire agli utenti di generare i propri token di autenticazione. Ad esempio, puoi trovare un codice campione per ottenere un token ID OIDC in modo programmatico nella documentazione di Identity-Aware Proxy.

Per generare un token di autenticazione:

1. Crea un account di servizio Google Cloud per cui generare un token ID OIDC:

   gcloud iam service-accounts create \
       $SERVICE_ACCOUNT \
       --display-name $SERVICE_ACCOUNT
   

2. Ottieni l'identità email dell'account di servizio:

   SA_EMAIL=${SERVICE_ACCOUNT}@${PROJECT}.iam.gserviceaccount.com
   

3. Concedi il ruolo IAM Creatore token account di servizio (roles/iam.serviceAccountTokenCreator) per l'account di servizio:

   gcloud iam service-accounts add-iam-policy-binding $SA_EMAIL \
       --member user:$(gcloud config get-value account) \
       --role roles/iam.serviceAccountTokenCreator
   

4. Utilizzando l'API IAM credenziali, genera un token ID OIDC.

   TOKEN=$(curl -s ${GENERATE_TOKEN}/${SA_EMAIL}:generateIdToken \
       -H "Content-Type: application/json" \
       -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
       -d '{"audience": "'${ENDPOINTS_SERVICE}'", "includeEmail": "true"}' | jq -r ".token")
   

   Il nome del servizio Endpoints è specificato nel campo audience. L'attestazione audience identifica il destinatario a cui è destinato il token.

5. Verifica che il token sia stato creato correttamente:

   echo $TOKEN
   

   Il token web JSON (JWT) è simile al seguente:

   eyJhbGciOiJSUzI1NiIsImtpZCI6IjY4NjQyODlm[...].eyJhdWQiOiJwdWJ0ZXN0LmVuZHBvaW50cy52aXR
   hbC1vY3RhZ29uLTEwOTYxMi5jbG91ZC5nb[...].SjBI4TZjZAlYo6lFKkrvfAcVUp_AJzFKoSsjNbmD_n[...]
   

Chiamata a Pub/Sub tramite proxy

1. In Cloud Shell, pubblica un messaggio di prova:

   curl -i -k -X POST https://${ENDPOINTS_SERVICE}/publish \
       -H "Authorization: Bearer $TOKEN" \
       -H "Content-Type: application/json" \
       -d '{"topic": "'$TOPIC'", "messages": [ {"attributes": {"key1": "value1", "key2" : "value2"}, "data": "test data"}]}'
   

   L'output è simile al seguente:

   HTTP/2 200
   server: nginx
   date: Sun, 02 Jun 2019 03:53:46 GMT
   ...
   

2. Controlla se il messaggio è stato pubblicato correttamente nell'argomento Pub/Sub:

   kubectl logs -f --tail=5 deployment/pubsub-proxy -c pubsub-proxy
   

   I log di deployment del proxy Pub/Sub mostrano il messaggio Successfully published:

   2019-06-02 03:49:39.723:INFO:oejs.Server:main: Started @2554ms
   Jun 02, 2019 3:53:44 AM com.google.pubsub.proxy.publish.PublishMessage
   getPublisher
   INFO: Creating new publisher for: proxy-test
   Jun 02, 2019 3:53:47 AM
   com.google.pubsub.proxy.publish.PublishMessage$1 onSuccess
   INFO: Successfully published: 569006136173844
   

Risoluzione dei problemi

1. In Cloud Shell, controlla lo stato di entrambi i container nel pod proxy Pub/Sub:

   kubectl describe pods $(kubectl get pod -l app=pubsub-proxy \
       -o jsonpath="{.items[0].metadata.name}")
   

   Nell'output del log, lo stato dei container è Running:

   [...]
   Containers:
     esp:
   [...]
     State:  Running
       Started:  Fri, 21 Jun 2019 16:41:30 +0530
     Ready:  True
     Restart Count:  0
   [...]
     pubsub-proxy:
       State:  Running
         Started:  Fri, 21 Jun 2019 16:41:42 +0530
       Ready:  True
       Restart Count:  0
   [...]
   

2. (Facoltativo) Controlla i log del container per verificare se sono presenti altri errori. Ad esempio, per controllare i log del proxy Pub/Sub, esegui questo comando:

   kubectl logs -f --tail=10 deployment/pubsub-proxy -c pubsub-proxy
   

Per assistenza con la risoluzione dei problemi, consulta i seguenti documenti:

• Risoluzione dei problemi di Endpoints con GKE
• Risoluzione dei problemi relativi alla convalida JWT
• Risolvere gli errori di risposta