Questa pagina è stata tradotta dall'API Cloud Translation.

Attività di integrazione Kubernetes

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

Aggiunta di un plug-in personalizzato

Puoi aggiungere nuove caratteristiche e capacità al microgateway scrivendo plug-in personalizzati. I plug-in personalizzati ti consentono di interagire in modo programmatico con le richieste e le risposte che passano attraverso il microgateway.

Questa sezione spiega come pacchettizzare ed eseguire il deployment di plug-in in un'istanza Edge Microgateway in esecuzione nel tuo cluster Kubernetes.

Il resto di questa sezione presuppone che tu abbia familiarità con la scrittura e la configurazione dei plug-in per una configurazione standard di Edge Microgateway. In caso contrario, consulta l'articolo Sviluppare plug-in personalizzati.

Crea un pacchetto dei tuoi plug-in

Per creare un pacchetto di plug-in personalizzati, procedi nel seguente modo:

Scrivi e testa il plug-in in base alle istruzioni riportate in Scrivere un plug-in semplice.
Inserisci il codice plug-in nella struttura della directory corretta. Le directory dei plug-in devono seguire una struttura prestabilita. L'esempio seguente mostra la struttura da seguire, dove response-uppercase e request-headers sono i nomi delle cartelle contenenti il codice plug-in personalizzato (questi nomi sono solo esempi, i nomi delle cartelle potrebbero essere diversi):
```
plugin
  |
  |-- plugins
    |
    |- response-uppercase
    |     |- index.js
    |     |- package.json
    |- request-headers
    |     | - index.js
          | - package.json
```
cd nella cartella plugin.
Nella cartella plugin, comprimi l'intera cartella plugins:
```
zip -r plugins.zip plugins/
```

Crea un'immagine Docker

Nella stessa directory in cui si trova il file ZIP, crea un nuovo file denominato Dockerfile.

Aggiungi il seguente codice a Dockerfile e salva il file:

FROM gcr.io/apigee-microgateway/edgemicro:latest
RUN apt-get install unzip
COPY plugins.zip /opt/apigee/
RUN chown apigee:apigee /opt/apigee/plugins.zip
RUN su - apigee -c "unzip /opt/apigee/plugins.zip -d /opt/apigee"
EXPOSE 8000
EXPOSE 8443
ENTRYPOINT ["entrypoint"]

Crea una nuova immagine Docker Edge Microgateway con i tuoi plug-in ed esegui il push dell'immagine al registro Docker. Puoi utilizzare qualsiasi registro, ad esempio docker.io o gcr.io:
```
docker build -t edgemicroplugins .
docker tag edgemicroplugins container-registry/your-project/edgemicroplugins
docker push container-registry/your-project/edgemicroplugins
```
Ad esempio:
```
docker build -t edgemicroplugins .
docker tag edgemicroplugins gcr.io/my-project/edgemicroplugins
docker push   gcr.io/my-project/edgemicroplugins
```
Nota: se utilizzi Google Container Registry (GCR), assicurati che l'immagine caricata disponga delle autorizzazioni appropriate. Ad esempio, per pubblicare l'immagine pubblicamente, rendi pubblicamente accessibile il bucket di archiviazione del registro dei container eseguendo questo comando. Ad esempio: gsutil iam ch allUsers:objectViewer gs://[BUCKET_NAME]

Aggiorna la configurazione di Edge Microgateway

Aggiungi i plug-in al file di configurazione Edge Microgateway. Puoi trovare il file di configurazione qui:
```
$HOME/.edgemicro/org-env-config.yaml
```
Ad esempio:
```
$HOME/.edgemicro/myorg-test-config.yaml
```

Nella seguente configurazione di esempio, è stato aggiunto il plug-in personalizzato response-uppercase. Il plug-in oauth era già presente per impostazione predefinita.

  edgemicro:
    ...
    plugins:
      sequence:
        - oauth
        - response-uppercase

Aggiorna il cluster Kubernetes

Il passaggio finale consiste nell'applicare la modifica alla configurazione al cluster Kubernetes. Kubernetes estrarrà la nuova immagine con il codice plug-in di cui hai eseguito il push al Container Registry e lo utilizzerà per tutti i pod appena creati.

Se hai eseguito il deployment di Edge Microgateway as a Service

Utilizza il comando edgemicroctl per inserire la configurazione aggiornata di Edge Microgateway:

Aggiorna il deployment del Microgateway Edge con la nuova immagine. Ad esempio:
```
kubectl apply -f <(edgemicroctl -org=your_organization -env=your_environment -key=configuration_key -sec=configuration_secret -conf=config_file_path -img=container-registry/your_project_name/image_name:latest)
```
dove:
- your_organization: l'organizzazione Apigee specificata nel comando edgemicro configure.
- your_environment: l'ambiente specificato nel comando edgemicro configure.
- configuration_key: la chiave restituita dal comando edgemicro configure.
- configuration_secret: il secret restituito dal comando edgemicro configure.
- config_file_path: il percorso del file di configurazione Edge Micro restituito dal comando edgemicro configure.
- container-registry: il registro Docker in cui hai eseguito il push dell'immagine. Ad esempio, gcr.io o docker.io
- your_project_name: il nome del progetto per il repository Docker in cui hai eseguito il push dell'immagine Docker.
- image_name: il nome dell'immagine Docker di cui hai eseguito il push.
Esempio:
```
kubectl apply -f <(edgemicroctl -org=jdoe -env=test -key=f2d2eaa52b758493d00cec656e574ac947bee1d701c5c5f3295e5eaa39a3b -sec=0c38cda3fac6c59152f15657052ba1728f8003c1a763cf08da2a -conf=/Users/jdoe/.edgemicro/apigeesearch-test-config.yaml -img=gcr.io/jdoe-project/edgemicroplugins:latest)
```
Testa il plug-in. Chiama l'API per vedere se ottieni il comportamento previsto. Ad esempio, per il plug-in "risposta in maiuscolo", il testo della risposta viene convertito in lettere tutte maiuscole, come mostrato di seguito:
```
curl $GATEWAY_IP -H 'x-api-key:3eqeedJRFLlCshwWBiXq4xKFoH1Se3xR'
```
Output:
```
HELLO WORLD
```

Inserimento manuale della nuova configurazione

L'inserimento manuale è un approccio semplice, che consente di inserire la nuova configurazione dalla riga di comando.

Esegui questo comando:
```
kubectl apply -f <(edgemicroctl -org=your_org -env=your_env -key=your_key -sec=your_secret -conf=config_file_path -img=container-registry/your_project_name/image_name:latest -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 Edge Micro restituito dal comando edgemicro configure.
- container-registry: il registro Docker in cui hai eseguito il push dell'immagine. Ad esempio, gcr.io o docker.io
- your_project_name: il nome del progetto per il repository Docker in cui hai eseguito il push dell'immagine Docker.
- image_name: il nome dell'immagine Docker di cui hai eseguito il push.
- service_deployment_file: il percorso del file di deployment del servizio a cui verranno applicati i plug-in. 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 -img=gcr.io/myproject/edgemicroplugins:latest -svc=samples/helloworld/helloworld.yaml)
```
Testa il plug-in. Chiama l'API del servizio per vedere se ottieni il comportamento previsto. Ad esempio, per il plug-in "risposta in maiuscolo", il testo della risposta viene convertito in tutto maiuscolo, come mostrato di seguito:
```
curl $GATEWAY_IP -H 'x-api-key:3eqeedJRFLlCshwWBiXq4xKFoH1Se3xR'
```
Output:
```
HELLO WORLD
```

Modifiche alla configurazione di Edge Microgateway

In alcuni casi, potresti dover modificare la configurazione del gateway perimetrale. Ad esempio, potresti voler aggiungere un nuovo plug-in a Edge Microgateway o modificare un parametro di configurazione. Questa sezione spiega come apportare e applicare modifiche alla configurazione a Edge Microgateway in esecuzione in Kubernetes.

Crea un file di configurazione secret.yaml come mostrato di seguito:

Nota: le informazioni necessarie per eseguire gli aggiornamenti della configurazione sono archiviate in un oggetto segreto di Kubernetes chiamato mgwsecret.
```
apiVersion: v1
kind: Secret
metadata:
  name: mgwsecret
type: Opaque
data:
  mgorg: EDGEMICRO_ORG
  mgenv: EDGEMICRO_ENV
  mgkey: EDGEMICRO_KEY
  mgsecret: EDGEMICRO_SECRET
  mgconfig: EDGEMICRO_CONFIG
```

Specifica il valore codificato in Base64 di EDGEMICRO_ORG, EDGEMICRO_ENV, EDGEMICRO_KEY, EDGEMICRO_SECRET:

echo -n "your-org" | base64 | tr -d '\n'
echo -n "your-org-env" | base64 | tr -d '\n'
echo -n "your-mg-key" | base64 | tr -d '\n'
echo -n "your-mg-secret" | base64 | tr -d '\n'

Apporta le modifiche al file di configurazione Edge Microgateway per la tua organizzazione e il tuo ambiente:
```
$HOME/.edgemicro/your_org-your_env-config.yaml
```

Codifica Base64 il doppio dei contenuti del file di configurazione:

cat $HOME/.edgemicro/org-env-config.yaml | base64 | tr -d '\n' | base64  | tr -d '\n'

Applica le modifiche a Kubernetes nello spazio dei nomi in cui è in esecuzione il servizio.
```
kubectl apply -f secret.yaml -n 
```

Queste nuove modifiche non vengono applicate automaticamente dai pod microgateway esistenti, ma i nuovi pod riceveranno le modifiche. Puoi eliminare il pod esistente in modo che il deployment crei un nuovo pod che rilevi la modifica.

Esempio di servizio

L'esempio seguente illustra come aggiornare il deployment di un servizio con un nuovo

Recupera i pod.

kubectl get pods

Output di esempio:

NAME                                 READY     STATUS    RESTARTS   AGE
edge-microgateway-57ccc7776b-g7nrg   1/1       Running   0          19h
helloworld-6987878fc4-cltc2          1/1       Running   0          1d

Elimina il pod edge-microgateway.

kubectl delete pod edge-microgateway-57ccc7776b-g7nrg

Output di esempio:

pod "edge-microgateway-57ccc7776b-g7nrg" deleted

Recupera di nuovo i pod. Un nuovo pod si avvia e riceve le modifiche alla configurazione.

kubectl get pods

Output di esempio:

NAME                                 READY     STATUS    RESTARTS   AGE
edge-microgateway-57ccc7776b-7f6tc   1/1       Running   0          5s
helloworld-6987878fc4-cltc2          1/1       Running   0          1d

Scalare il deployment

Questa sezione spiega come utilizzare i principi di scalabilità di Kubernetes per scalare i deployment.

Scalabilità del deployment di un servizio

Controlla i deployment:

kubectl get deployments

Output di esempio:

NAME                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
edge-microgateway   1         1         1            1           18h
helloworld          1         1         1            1           1d

L'output indica che è stato eseguito il deployment di una replica.

Scala il deployment da 1 a tutte le repliche che vuoi. In questo esempio, il servizio edge-microgateway è in scala.
```
kubectl scale deployment edge-microgateway --replicas=2
```
(Facoltativo) Se vuoi utilizzare la scalabilità automatica, utilizza questo comando:
```
kubectl autoscale deployment edge-microgateway --cpu-percent=50 --min=1 --max=10
```

Controlla i deployment per verificare che la scalabilità sia abilitata:

kubectl get deployments

Output di esempio:

NAME                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
edge-microgateway   2         2         2            2           18h
helloworld          1         1         1            1           1d

Lo stato è stato modificato per includere due repliche.

Controlla i pod:

kubectl get pods

Output di esempio:

NAME                                 READY     STATUS    RESTARTS   AGE
edge-microgateway-57ccc7776b-g7nrg   1/1       Running   0          18h
edge-microgateway-57ccc7776b-rvfz4   1/1       Running   0          41s
helloworld-6987878fc4-cltc2          1/1       Running   0          1d

L'output mostra che entrambe le repliche sono in esecuzione.

Utilizza gli spazi dei nomi per più configurazioni Edge Microgateway

Puoi eseguire il deployment e configurare più istanze dei servizi Edge Microgateway nel tuo cluster Kubernetes. Questo caso d'uso consente di configurare ogni istanza di microgateway con il proprio set di plug-in e parametri. Ad esempio:

Edge Microgateway Service A richiede solo il plug-in di arresto dei picchi.
Edge Microgateway Service B richiede la quota e il plug-in OAuth, ma non l'arresto per picchi di traffico.

Per affrontare questo caso d'uso, utilizza gli spazi dei nomi Kubernetes. Ad esempio, puoi eseguire il deployment del servizio Edge Microgateway A nello spazio dei nomi foo e del servizio Edge Microgateway B nello spazio dei nomi bar.

Nell'esempio seguente, viene eseguito il deployment di Edge Microgateway configurato nell'organizzazione OrgA come servizio nello spazio dei nomi foo utilizzando l'opzione -n:

kubectl apply -f <(edgemicroctl -org=myorgA -env=test-key=0e3ecea28a64099410594406b30e54439af5265f8 -sec=e3919250bee37c69cb2e5b41170b488e1c1d -conf=/Users/joed/.edgemicro/orgA-test-config.yaml -svc=samples/helloworld/helloworld.yaml) -n foo

Allo stesso modo, nell'esempio seguente viene eseguito il deployment di Edge Microgateway configurato nell'organizzazione OrgB come servizio nello spazio dei nomi bar utilizzando l'opzione -n:

kubectl apply -f <(edgemicroctl -org=myorgB -env=test-key=0e3ecea28a64099410594406b30e54439af5265f8 -sec=e3919250bee37c69cb2e5b41170b488e1c1d -conf=/Users/joed/.edgemicro/orgB-test-config.yaml -svc=samples/helloworld/helloworld.yaml) -n bar