Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment di Edge Microgateway come proxy sidecar

Stai visualizzando la documentazione di Apigee Edge.
Vai alla sezione Documentazione di Apigee X. Informazioni

OBSOLETO: microgateway Running Edge in Kubernetes è supportato l'uso di pattern proxy collaterali; tuttavia, edgemicroctl e i relativi strumenti descritti in questo argomento sono deprecati. Questi strumenti si basano injector collaterale, che non è più supportato.

Introduzione

Questo argomento spiega come eseguire Edge Microgateway in un cluster Kubernetes come un proxy collaterale. Hai due opzioni per l'implementazione collaterale: manuale e automatica iniezione di codice. Questo argomento descrive entrambe le opzioni.

Per ulteriori informazioni, consulta Introduzione a Edge Microgateway su Kubernetes.

Prima di iniziare

Completa i passaggi descritti nella sezione Prerequisiti.

esegui il deployment di un servizio di test

Esegui il deployment di una semplice e verificare il deployment:

Esegui il deployment dell'esempio:

kubectl apply -f samples/helloworld/helloworld.yaml --namespace=default

Verifica che il servizio sia in esecuzione. Potresti dover attendere qualche istante prima che il pod passa allo stato di esecuzione:
```
kubectl get pods --namespace=default
```
Output di esempio:
```
NAME                          READY     STATUS    RESTARTS   AGE
helloworld-569d6565f9-lwrrv   1/1       Running   0          17m
```
Nota: tieni presente che lo stato PRONTO di 1/1 significa che c'è "uno di uno". in esecuzione nel pod. Nella i seguenti passaggi, configurare il cluster in modo che Edge Microgateway venga inserito automaticamente come in qualsiasi nuovo pod che crei. In questo caso, vedrai quando esegui kubectl get pods, che ci sono "due di due" servizi in esecuzione nel pod: il servizio e il file collaterale.
Elimina il deployment del servizio di test. Lo reinstallerai in un secondo momento, dopo l'attivazione iniezione collaterale:
```
 kubectl delete -f samples/helloworld/helloworld.yaml --namespace=default
```

Utilizzo dell'inserimento manuale di file collaterali

Tra le due opzioni di iniezione di file collaterali, quella manuale è quella più semplice e diretta e può essere eseguita con un singolo comando kubectl.

Configura Edge Microgateway

Il comando seguente configura Edge Microgateway per la tua organizzazione Apigee ed esegue il deployment del proxy edgemicro-auth.

Esegui questo comando:

edgemicro configure -o [org] -e [env] -u [username]

Dove:

org: il nome dell'organizzazione Edge (devi essere un amministratore dell'organizzazione).
env: un ambiente nella tua organizzazione, ad esempio test o produzione.
username: l'indirizzo email associato al tuo account Apigee.

di Gemini Advanced.

Esempio

edgemicro configure -o myorg -e test -u jdoe@example.com

L'output (l'esempio mostrato di seguito) viene salvato nel file:

$HOME/.edgemicro/org_name-env_name-config.yaml

current nodejs version is v6.9.1
current edgemicro version is 2.5.25
password:
file doesn't exist, setting up
Give me a minute or two... this can take a while...
App edgemicro-auth deployed.
checking org for existing KVM
KVM already exists in your org
configuring host edgemicroservices.apigee.net for region us-west1

saving configuration information to: /Users/jdoe/.edgemicro/myorg-test-config.yaml

vault info:
 -----BEGIN CERTIFICATE-----
MIICpDCCAYwCCQCV9eBcO9a5WzANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDDAls
b2NhbGhvc3QwHhcNMagwODA5MDAzMDEzWhcNMTgwODEwMDAzMDEzWjAUMRIwEAYD
VQQDDBlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDh
nAHT7JHX/WvWHRFb8FLm53SPIDld5LyPOUfINdEyhSIEeXoOUKg4EPweJPVSC9Vm
Hw4ZMtEqWJM/XsQWvLe8ylRJa5wgmzmFCqAsuzs9+rmc9KvJqjpOh2uRTUf7KKfT
iXL2UEseprcI5g8zNyqKyEf/ecWIwz3AkkPAZebVTsrdDfIDHvkyhhvlAHZAB9kn
GtqP3N8kOlv4KQto9Gr7GYUGUIDugt7gM1F611+RBS+fYRi32GUAq/UQDkhYL8cp
oIJiF7UYkk2+9t9CdOCDuIUCvJioHJQd0xvDpkC9f6LvwjwnCwku+4F2Q63+av5I
mJoZJQPvW5aP53Qkk+kHAgMBAAEwDKYJKoZIhvcNAQELBQADggEBALyUBolXUFN8
1bf268nR+gS8MOFDTxO1bUz+bKuT/g3K1PuNUJTueT+0L1H2OiZUzazAqwn2sqzN
lQuvLg6LjxjlNkqTJGiJvGDcYVq45dv7UyxAZxhqxTxhlQ+Yu5R9pbQnzujezHpH
6gtCoCkSt/QqiJ3YsmsVu5is+HpIJepMt0CyMh5tK9j87hl46QhHklaVfQ3ycMVm
/wNPR/pjizg1FDUeq4nj/7DBVbMf9net/BDaZLeSW1HJ1vcsCXIcSZfQd4QymGFn
8ADrND7ydVjwO/s23soPDTy0g4yLIZvky2tpT8d7YahNqSv2n7sXsLxruzcyCoQ4
w+e3Z3F7IKI=
-----END CERTIFICATE-----

The following credentials are required to start edge micro
  key: 1a3b2754c7f20614817b86e09895825ecc252d34df6c4be21ae24356f09e6eb4
  secret: 16ad2431de73f07f57a6d44048f08d93b63f783bf1f2ac4221182aa7289c7cef

edgemicro configuration complete!

Inserisci Edge Microgateway come file collaterale

Per inserire manualmente Edge Microgateway in un pod di servizio come proxy collaterale, esegui questo comando:

kubectl apply -f <(edgemicroctl -org=your_org -env=your_env -key=your_key -sec=your_secret -conf=config_file_path -svc=service_deployment_file)

dove:

your_org: l'organizzazione Apigee specificata nel comando edgemicro configure.
your_env: l'ambiente specificato nel comando edgemicro configure.
your_key: la chiave restituita dal comando edgemicro configure.
your_secret: il secret restituito dal comando edgemicro configure.
config_file_path - Il percorso del file di configurazione di Edge Micro restituito dal comando edgemicro configure.
service_deployment_file - Il percorso del file di deployment del servizio il cui pod verrà ottenere il servizio collaterale companion. Ad esempio: samples/helloworld/helloworld.yaml.

Ad esempio:

kubectl apply -f <(edgemicroctl -org=myorg -env=test-key=0e3ecea28a64099410594406b30e54439af5265f8 -sec=e3919250bee37c69cb2e5b41170b488e1c1d -conf=/Users/jdoe/.edgemicro/myorg-test-config.yaml -svc=samples/helloworld/helloworld.yaml)

Testa la configurazione

Controlla i deployment dei servizi:

kubectl get services -n default

Output di esempio:

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
helloworld   NodePort    10.15.254.163   <none>        8081:32401/TCP   56s
kubernetes   ClusterIP   10.15.240.1     <none>        443/TCP          41m

Ora puoi testare il deployment collaterale di Edge Microgateway. Vai a Testa il proxy per la procedura dettagliata.

Utilizzo dell'inserimento automatico di file collaterali

Nei seguenti passaggi, configurerai l'inserimento automatico del file collaterale per il tuo in un cluster Kubernetes. Questa configurazione consente di inserire Edge Microgateway come file collaterale in Kubernetes.

Installa l'iniettore del sidecar

Installa ConfigMap che consente l'inserimento di file collaterali di Edge Microgateway:

kubectl apply -f install/kubernetes/edgemicro-sidecar-injector-configmap-release.yaml

Esegui lo script seguente per installare il servizio webhook. Il servizio webhook è obbligatorio per iniezione automatica del file collaterale:

Nota: un servizio webhook richiede una coppia di certificato/chiave firmato. Lo script seguente genera una coppia di certificato/chiave firmata dall'autorità di certificazione (CA) di Kubernetes. Il file del certificato/della chiave risultante viene archiviato come secret di Kubernetes per il file collaterale webhook di iniettore da utilizzare. L'approvazione delle CA per Kubernetes richiede le autorizzazioni per creare e approvare richiesta di firma del certificato (CSR). Vedi anche Gestire i TLS in un cluster ed esamina lo script install/kubernetes/webhook-create-signed-cert.sh per ulteriori informazioni.
```
./install/kubernetes/webhook-create-signed-cert.sh \
    --service edgemicro-sidecar-injector \
    --namespace edgemicro-system \
    --secret sidecar-injector-certs
```

Aggiungi il bundle CA al file di installazione del webhook. Il cluster Kubernetes api-server utilizza questo file per richiamare il webhook:

cat install/kubernetes/edgemicro-sidecar-injector.yaml | \
     ./install/kubernetes/webhook-patch-ca-bundle.sh > \
     install/kubernetes/edgemicro-sidecar-injector-with-ca-bundle.yaml

Installa il webhook dell'iniettore del sidecar Edge Microgateway:

kubectl apply -f install/kubernetes/edgemicro-sidecar-injector-with-ca-bundle.yaml

Output di esempio:

service "edgemicro-sidecar-injector" created
serviceaccount "edgemicro-sidecar-injector-service-account" created
deployment "edgemicro-sidecar-injector" created
mutatingwebhookconfiguration "edgemicro-sidecar-injector" created

Verifica che il webhook dell'iniettore del sidecar Edge Microgateway sia in esecuzione:

kubectl -n edgemicro-system get deployment -ledgemicro=sidecar-injector

Output di esempio:

NAME                         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
edgemicro-sidecar-injector   1         1         1            1           12m

Verifica che il pod di inserimento del file collaterale sia in esecuzione nel cluster. Lo spazio dei nomi edgemicro-system è il luogo in cui vengono installati i servizi di sistema, incluso il Controller Ingress, backend HTTP predefinito e injector del sidecar:

kubectl get pods -n edgemicro-system

Output di esempio:

NAME                                            READY     STATUS    RESTARTS   AGE
default-http-backend-55c6c69b88-gfnfd           1/1       Running   0          1h
edgemicro-ingress-controller-64444469bf-jhn8b   1/1       Running   3          1h
edgemicro-sidecar-injector-7d95698fbf-cq84q     1/1       Running   0          3m

Configura e inserisci Edge Microgateway

Nel passaggio successivo, eseguirai uno script interattivo per creare un Microgateway Edge associata a uno spazio dei nomi Kubernetes. Quindi, dovrai inserire nel tuo cluster Kubernetes.

Esegui il seguente script interattivo e fornisci i parametri richiesti. La genera un profilo di configurazione che utilizzerai nel passaggio successivo.
```
./install/kubernetes/webhook-edgemicro-patch.sh
```
Per informazioni sui parametri di input, consulta la sezione Riferimento.

Input di esempio:
1. Namespace to deploy application [default]:
  
  Premi Invio.
2. Authenticate with OAuth Token ("n","Y") [N/y]
  
  Inserisci n.
3. Apigee username [required]:
  
  Inserisci il tuo nome utente (indirizzo email) Apigee. Ad esempio: jdoe@google.com.
4. Apigee password [required]:
  
  Inserisci la tua password Apigee.
5. Apigee organization [required]:
  
  Inserisci il nome della tua organizzazione Apigee.
6. Apigee environment [required]:
  
  Inserisci un nome ambiente per la tua organizzazione. Ad esempio "test".
7. Virtual Host [default]:
  
  Premi Invio.
8. Is this Private Cloud ("n","y") [N/y]:
  
  Inserisci n se ti trovi su un cloud pubblico.
9. Edgemicro Key. Press Enter to generate:
  
  Premi Invio.
10. Edgemicro Secret. Press Enter to generate:
  
  Premi Invio.
11. Edgemicro org-env-config.yaml. Press Enter to generate:
  
  Premi Invio.
  
  Output di esempio:
```
current nodejs version is v6.9.1
current edgemicro version is 2.5.25
config initialized to /Users/jdoe/.edgemicro/default.yaml
Configure for Cloud
******************************************************************************************
Config file is Generated in /Users/jdoe/Work/GITHUB/microgateway_2.5.25_Darwin_x86_64/config directory.

Please make changes as desired.
*****************************************************************************************
```
12. Do you agree to proceed("n","y") [N/y]:
  
  Inserisci y.
  
  Output di esempio:
```
Configuring Microgateway with

key:daacf75dd660d160b801c9117fb1ec0935896615479e39dbbae88be81a2d84
secret:a60fd57c1db9f3a06648173fb541cb9c59188d3b6037a76f490ebf7a6584b0
config:~/.edgemicro/jdoe-test-config.yaml

********************************************************************************************************
kubectl apply -f install/kubernetes/edgemicro-config-namespace-bundle.yaml
********************************************************************************************************
```
di Gemini Advanced.
Nota: puoi anche passare parametri allo script per un uso non interattivo. Per informazioni dettagliate, leggi i commenti in ./install/kubernetes/webhook-edgemicro-patch.sh.
Esegui il comando fornito nell'ultima riga dell'output. Questo comando kubectl inserisce il profilo di configurazione Edge Microgateway generato in Kubernetes:
```
kubectl apply -f install/kubernetes/edgemicro-config-namespace-bundle.yaml
```

Visualizza lo stato dell'inserimento del webhook. Tieni presente che al momento non è abilitato:

kubectl get namespace -L edgemicro-injection

Output di esempio:

NAME               STATUS    AGE       EDGEMICRO-INJECTION
default            Active    1d
edgemicro-system   Active    1d
kube-public        Active    1d
kube-system        Active    1d

Esegui questo comando per attivare l'inserimento del webhook per il webhook:
```
kubectl label namespace default edgemicro-injection=enabled
```

Visualizza di nuovo lo stato dell'inserimento del webhook. Tieni presente che ora è abilitato:

kubectl get namespace -L edgemicro-injection

Output di esempio:

NAME               STATUS    AGE       EDGEMICRO-INJECTION
default            Active    1d        enabled
edgemicro-system   Active    1d
kube-public        Active    1d
kube-system        Active    1d

esegui il deployment del servizio di test

Ora esegui di nuovo il deployment del servizio di test. Edge Microgateway verrà inserito automaticamente nel pod del servizio.

kubectl apply -f samples/helloworld/helloworld.yaml --namespace=default

Verifica che Edge Microgateway sia stato inserito nel pod insieme al test servizio:

kubectl get pods --namespace=default --watch

Output di esempio:

NAME                          READY     STATUS            RESTARTS   AGE
helloworld-6987878fc4-pkw8h   0/2       PodInitializing   0          12s
helloworld-6987878fc4-pkw8h   2/2       Running           0         26s

Quando lo stato passa a Running, premi ctrl-c per uscire dal comando.

Ora puoi testare il deployment collaterale automatico di Edge Microgateway. Vai a Testa il proxy per la procedura dettagliata.

Testa il proxy

Con il deployment sidecar, viene creato automaticamente un proxy API per il tuo servizio. Tu sì non è necessario creare un "Edge Microgateway-aware" proxy.

Recupera l'indirizzo IP Ingress

Con l'IP esterno per la risorsa Ingress, puoi chiamare il servizio dall'esterno del cluster.

Ottieni l'indirizzo IP esterno del controller Ingress:

kubectl get ing -o wide

Output di esempio:

NAME      HOSTS     ADDRESS        PORTS     AGE
gateway   *         35.238.13.54   80        1m

Copia il valore EXTERNAL-IP per l'oggetto Ingress ed esportalo in una variabile. Tu puoi impostare la variabile manualmente:
```
export GATEWAY_IP=external_ip
```
Ad esempio:
```
export GATEWAY_IP=35.238.249.62
```
In alternativa, utilizza questo comando per impostarlo per te:
```
export GATEWAY_IP=$(kubectl describe ing gateway --namespace default | grep "Address" | cut -d ':' -f2 | tr -d "[:space:]")
```
Verifica che la variabile sia stata esportata. Ad esempio:
```
echo $GATEWAY_IP
```
Output di esempio:
```
35.238.249.62
```
Chiama il servizio:
```
curl $GATEWAY_IP
```
Output:
```
{"error":"missing_authorization","error_description":"Missing Authorization header"}
```
Successivamente, correggerai l'errore di autorizzazione mancante configurando un prodotto API e un'app per sviluppatori. su Edge, in modo da poter ottenere una chiave API valida. Quando aggiungi la chiave a un'autorizzazione per la chiamata API, la chiamata avrà esito positivo e non verrà visualizzato questo errore.

Crea componenti su Apigee Edge

Ora crea un prodotto API e un'app per sviluppatori su Apigee Edge.

crea un prodotto API

Accedi ad Apigee Edge.
Seleziona Pubblica > Prodotti API nel menu di navigazione laterale.
Fai clic su + Prodotto API. Viene visualizzata la pagina del prodotto.
Compila la pagina Prodotto come segue. Per i campi non menzionati di seguito, possono utilizzare i valori predefiniti. Non salvare finché non ti viene chiesto di farlo.

Nome hello-world-product

Nome visualizzato Edge Micro hello product

Ambiente test
Nella sezione Percorso, fai clic su + Risorsa personalizzata.
Aggiungi il percorso /.
Fai di nuovo clic su + Risorsa personalizzata e aggiungi il percorso /**.
Nella sezione Proxy API, fai clic su + Proxy API e aggiungi edgemicro-auth.
Salvare il prodotto API.

Creazione di un'app sviluppatore

Seleziona App nel menu di navigazione laterale.
Fai clic su + App. Viene visualizzata la pagina dei dettagli dell'app sviluppatore.
Compila la pagina dell'app sviluppatore come segue. Non salvare finché non ti viene chiesto di farlo.

Nome hello-world-app

Nome visualizzato Edge Micro hello app

Developer Seleziona uno sviluppatore dal menu a discesa.
Nella sezione Credentials (Credenziali), fai clic su + Product (+ Prodotto) e seleziona l' hello-world-product che hai appena creato.
Fai clic su Salva.
Torni alla pagina che elenca tutte le app sviluppatore.
Seleziona l'app che hai appena creato, hello-world-app.
Fai clic su Show (Mostra) accanto a Consumer Key (Chiave utente).
Copia il valore della chiave utente. Questo valore corrisponde al Chiave API da utilizzare per effettuare chiamate API sicure a il servizio helloworld.
Attendi qualche minuto. Le modifiche apportate su Apigee richiedono alcuni minuti Edge per sincronizzarsi con l'istanza di Edge Microgateway di cui è stato eseguito il deployment in un cluster Kubernetes.

Nota: Edge Microgateway esegue il polling delle modifiche apportate su Apigee Edge ogni 600 secondi (per impostazione predefinita) ed esegue il pull di eventuali modifiche alla configurazione apportate ai proxy, prodotti basati su API e app per sviluppatori. Puoi cambiare l'impostazione predefinita di 600 modificando l'area File di configurazione del microgateway. Consulta il microgateway Edge documentazione per maggiori dettagli.

Chiama l'API

Dopo aver inserito le modifiche alla configurazione nel microgateway, puoi eseguire i seguenti test.

Chiama l'API senza una chiave API. Riceverai un messaggio di errore, come illustrato sotto:
```
curl $GATEWAY_IP
```
Output previsto:
```
{"error":"missing_authorization","error_description":"Missing Authorization
header"}
```
Per effettuare chiamate API riuscite, è necessaria la chiave API.
Ottieni la chiave consumer dall'app sviluppatore che hai creato. Questo valore corrisponde al Chiave API che devi chiamare il proxy di test:
```
curl -H 'x-api-key:your-edge-api-key'  $GATEWAY_IP
```
Ad esempio:
```
curl -H "x-api-key:DeX2eEesYAdRJ5Gdbo77nT9uUfJZql19" $GATEWAY_IP
```
Output:
```
Hello world
```
Il file "Hello World" viene restituita dal servizio helloworld di cui è stato eseguito il deployment nel pod. La chiamata al servizio è passata prima attraverso Edge Microgateway, in cui è stata eseguita l'autenticazione. Se visualizzi "Hello World" risposta, hai configurato correttamente Edge Microgateway per Funzionano da proxy collaterale nel pod di servizio helloworld.

Passaggi successivi

Per informazioni, consulta la sezione Attività sull'aggiunta di plug-in personalizzati, la scalabilità del deployment, le modifiche alla configurazione e altre attività che potresti voler eseguire.

Nome	`hello-world-product`
Nome visualizzato	`Edge Micro hello product`
Ambiente	`test`

Nome	`hello-world-app`
Nome visualizzato	`Edge Micro hello app`
Developer	Seleziona uno sviluppatore dal menu a discesa.