Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment di Edge Microgateway come servizio

Stai visualizzando la documentazione di Apigee Edge.
Vai alla documentazione di Apigee X. informazioni

Introduzione

Questo argomento spiega come eseguire Edge Microgateway in un cluster Kubernetes come servizio autonomo.

Per saperne di più, consulta la panoramica sull'integrazione di Edge Microgateway con Kubernetes.

Prima di iniziare

Completa la procedura descritta nella sezione Prerequisiti.

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: nome della tua organizzazione Edge (devi essere un amministratore dell'organizzazione).
env: un ambiente della tua organizzazione (ad esempio test o produzione).
username: l'indirizzo email associato al tuo account Apigee.

Esempio

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

L'output (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!

Esegui il deployment di Edge Microgateway as a Service

Esegui questo comando per eseguire il deployment di Edge Microgateway come servizio nel tuo cluster Kubernetes:
```
kubectl apply -f <(edgemicroctl -org=org -env=env -key=edgemicro-key
-sec=edgemicro-secret -conf=file path of org-env-config.yaml)
```
dove:
- org: l'organizzazione Apigee specificata nel comando edgemicro configure.
- env: l'ambiente specificato nel comando edgemicro configure.
- edgemicro-key: la chiave restituita dal comando edgemicro configure.
- edgemicro-secret: il secret restituito dal comando edgemicro configure.
- file path of org-env-config.yaml: il percorso del file di configurazione Edge Micro restituito dal comando edgemicro configure.
Ad esempio:
```
kubectl apply -f <(edgemicroctl -org=jdoe -env=test -key=989cce9d41cac94e72626d906562a1d76a19445f8901b3508858bb064988eccb -sec=ec92b793178de7b7e88e346f55a951e3fdae05e700e3ddea7d63977826379784 -conf=/Users/jdoe/.edgemicro/jdoe-test-config.yaml)
```
Output di esempio:
```
config/myorg-test-config.yaml)
service "edge-microgateway" created
deployment "edge-microgateway" created
secret "mgwsecret" created
```
Copia e incolla il seguente codice nel terminale. Il codice configura il controller Ingress in modo da consentire l'accesso esterno al servizio edge-microgateway. Potresti dover premere Invio dopo aver incollato il comando nel terminale:
```
cat <<EOF | kubectl apply -f -
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: edge-microgateway-ingress
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  rules:
  - http:
      paths:
      - path: /
        backend:
          serviceName: edge-microgateway
          servicePort: 8000
EOF
```
Se l'operazione va a buon fine, visualizzerai questo output:
```
ingress "edge-microgateway-ingress" created
```
Il controller Ingress è ora configurato in modo da consentire l'accesso esterno al servizio edge-microgateway.

Esegui il deployment di un servizio di test

I passaggi seguenti consentono di eseguire il deployment di un semplice servizio di test nel cluster. Il controller Ingress non consente di chiamare il servizio dall'esterno del cluster. In seguito, configurerai Edge Microgateway in modo che chiami il servizio come destinazione. Il controller Ingress consente l'accesso dall'esterno al servizio edge-microgateway.

Esegui il deployment del servizio helloworld di esempio. Poiché il servizio Ingress non è a conoscenza di questo servizio, non può essere chiamato dall'esterno del cluster.
```
kubectl apply -f samples/helloworld/helloworld-service.yaml
```
Output di esempio:
```
service "helloworld" created deployment "helloworld" created
```

Verifica che il deployment sia riuscito. Tieni presente che non esiste un IP esterno per il servizio helloworld. Nei passaggi seguenti, configurerai Edge Microgateway per accedere all'IP interno del servizio.

kubectl get services -n default

Output di esempio:

NAME                TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
edge-microgateway   NodePort    10.35.247.222   <none>        8000:32000/TCP   12m
helloworld          NodePort    10.35.245.103   <none>        8081:30294/TCP   47s
kubernetes          ClusterIP   10.35.240.1     <none>        443/TCP          47m

Configura Edge Microgateway per il proxy per il servizio

Ottieni l'IP interno per il servizio helloworld e aggiungilo come destinazione di un proxy "microgateway-aware". La creazione di un proxy "consapevole al microgateway" è un requisito standard di Edge Microgateway.

Vedi anche Cosa devi sapere sui proxy compatibili con Microgateway.

Ottieni l'IP interno per il servizio di test

Ottieni l'IP e la porta del cluster interni per il servizio helloworld:

kubectl get services helloworld

Output di esempio:

NAME         TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
helloworld   NodePort   10.55.254.255   <none>        8081:30329/TCP   3m

Copia i valori di CLUSTER-IP e PORT. Nell'esempio riportato sopra, questi valori sono: 10.55.254.255 e 8081. I valori per il tuo sistema saranno diversi.

Crea un proxy sensibile al microgateway su Edge

Accedi all'interfaccia utente di Edge.
Seleziona la stessa organizzazione che hai specificato in precedenza quando hai configurato Edge Microgateway.
Seleziona Sviluppo > Proxy API nel menu di navigazione laterale.
Fai clic su + Proxy. Viene visualizzata la procedura guidata Crea un proxy.
Nella prima pagina della procedura guidata, seleziona Inverti proxy (più comune).
Tocca Avanti.
Nella pagina Dettagli della procedura guidata, configura come segue. Assicurati di compilare la procedura guidata esattamente come mostrato. Assicurati che il nome del proxy abbia il prefisso edgemicro_.
1. Nome proxy: edgemicro_hello
2. Percorso base proxy: /hello
  
  Importante: nel passaggio successivo, utilizza il numero di IP cluster e Porta ottenuto in precedenza. Questo è l'IP di destinazione del proxy.
3. API esistente: http://<cluster_ip>:<port>
  
  Ad esempio: http://10.55.254.255:8081
Tocca Avanti.
Nella pagina Sicurezza della procedura guidata, seleziona Passthrough (nessuno).
Tocca Avanti.
Nella pagina Host virtuali della procedura guidata, accetta i valori predefiniti.
Tocca Avanti.
Nella pagina Crea della procedura guidata, controlla le impostazioni del proxy. Assicurati che sia selezionato l'ambiente di test.
Fai clic su Crea ed esegui il deployment.

Creazione di uno sviluppatore

Puoi utilizzare uno sviluppatore esistente per i test oppure crearne uno nuovo nel seguente modo:

Seleziona Pubblica > Sviluppatori nel menu di navigazione laterale.
Fai clic su + Sviluppatore.
Compila la finestra di dialogo per creare un nuovo sviluppatore. Puoi utilizzare qualsiasi nome/indirizzo email sviluppatore che desideri.

Creazione di un prodotto API

Crea un prodotto API come descritto di seguito. Aggiungerai due proxy al prodotto: edgemicro-auth e edgemicro_hello.

Per saperne di più sulle opzioni di configurazione del prodotto, consulta Cosa devi sapere sulla configurazione dei prodotti API.

Seleziona Pubblica > Prodotti API nel menu di navigazione laterale.
Fai clic su + Prodotto API. Viene visualizzata la pagina Dettagli prodotto.
Compila la pagina Dettagli prodotto come segue. Non fare clic su Salva finché non ti viene chiesto di farlo.

Nome hello-world-product

Display Name Edge Micro hello product

Ambiente test

Accesso Public

Tipo di approvazione chiave Automatic
Nella metà inferiore della pagina, fai clic su + Risorsa personalizzata.
Imposta la risorsa su / (una singola barra).
Seleziona di nuovo + Risorsa personalizzata e aggiungi il percorso /**.
Nella parte inferiore della pagina, fai clic su + Proxy API.
Seleziona il proxy denominato edgemicro-auth.
Fai di nuovo clic su + Proxy API.
Seleziona il proxy sensibile al microgateway denominato edgemicro_hello.
Fai clic su Salva.

Creazione di un'app sviluppatore

Seleziona Pubblica > App nel menu di navigazione laterale.
Fai clic su + App. Viene visualizzata la pagina Dettagli app sviluppatore.
Compila la pagina App sviluppatore come segue. Non salvare fino a quando ti viene chiesto di farlo.

Nome hello-world-app

Display Name Edge Micro hello app

Developer Seleziona lo sviluppatore di test che hai creato o qualsiasi sviluppatore andrà bene.
Nella sezione Credenziali, fai clic su + Prodotto e seleziona il prodotto che hai creato: hello-world-product.
Fai clic su Salva.
Sei tornato alla pagina con l'elenco di tutte le app sviluppatore.
Seleziona l'app appena creata, hello-world-app.
Fai clic su Mostra accanto alla Chiave utente.
Copia il valore della chiave utente. Questo valore è la chiave API che utilizzerai per effettuare chiamate API sicure a /hello.
Attendi qualche minuto. Sono necessari alcuni minuti perché le modifiche apportate su Apigee Edge vengano sincronizzate con l'istanza di Edge Microgateway di cui è stato eseguito il deployment nel cluster.

Nota: Edge Microgateway esegue il polling delle modifiche apportate su Apigee Edge ogni 600 secondi (per impostazione predefinita) e recupera eventuali modifiche alla configurazione apportate a proxy, prodotti API e app per sviluppatori. Puoi cambiare il valore predefinito di 600s modificando il file di configurazione di Edge Microgateway. Per i dettagli, consulta la documentazione di Edge Microgateway.

Testa il proxy

Recuperare l'indirizzo IP Ingress

Con l'IP esterno per Ingress, puoi chiamare il servizio Edge Microgateway 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
edge-microgateway-ingress   *         35.238.249.62    80        37m

Copia il valore ADDRESS per la risorsa Ingress ed esportalo in una variabile. 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:

export GATEWAY_IP=$(kubectl describe ing edge-microgateway --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 l'API

Dopo che le modifiche alla configurazione sono state estratte nel microgateway, puoi provare a chiamare l'API. Utilizzerai l'IP del controller Ingress (che hai salvato nella variabile GATEWAY_IP per chiamare l'API, perché questo IP consente di chiamare il proxy dall'esterno del cluster Kubernetes). La mappatura da Ingress a Edge Microgateway è stata creata quando hai eseguito il deployment di Edge Microgateway nel cluster.

Chiama l'API senza una chiave API. Visualizzerai un messaggio di errore, come mostrato di seguito:
```
curl $GATEWAY_IP:80/hello/
```
Output previsto:
```
{"error":"missing_authorization","error_description":"Missing Authorization
header"}
```
Se viene visualizzato questo messaggio, è possibile che sia necessario attendere un po' più a lungo fino al completamento della sincronizzazione:
```
{"message":"no match found for /hello/","status":404}
```
Per effettuare correttamente chiamate API, è necessaria la chiave API.
Recupera la chiave utente dall'app sviluppatore che hai creato. Questo valore è la chiave API che devi chiamare il proxy di prova:
```
curl -H 'x-api-key:your-edge-api-key' $GATEWAY_IP:80/hello/
```
Ad esempio:
```
curl -H "x-api-key:DeX2eEesYAdRJ5Gdbo77nT9uUfJZql19" $GATEWAY_IP:80/hello/
```
Output:
```
Hello world
```
Se vedi la risposta "Hello world", significa che hai configurato correttamente Edge Microgateway per chiamare il servizio helloworld all'interno del cluster Kubernetes.

Passaggi successivi

Consulta la sezione Attività per informazioni su come aggiungere plug-in personalizzati, scalare il deployment, apportare modifiche alla configurazione e altre attività che potresti voler eseguire.

Nome	`hello-world-product`
Display Name	`Edge Micro hello product`
Ambiente	`test`
Accesso	`Public`
Tipo di approvazione chiave	`Automatic`

Nome	`hello-world-app`
Display Name	`Edge Micro hello app`
Developer	Seleziona lo sviluppatore di test che hai creato o qualsiasi sviluppatore andrà bene.