Utilizzo di Kubernetes con Code Engine

IBM Cloud® Code Engine è progettato in modo tale che non sia necessario interagire con la tecnologia su cui si basa. Tuttavia, se disponi già di strumenti basati su Kubernetes o Knative, puoi comunque utilizzarli con Code Engine. Code Engine supporta le API di Kubernetes (e Knative) e i relativi comandi CLI. Per ulteriori informazioni su Knative, consultare la guida " Utilizzo di Knative con Code Engine ".

Se decidi di utilizzare Kubernetes con Code Engine, considera le seguenti informazioni:

La maggior parte dei contenitori o dei pod eseguiti su Kubernetes vengono eseguiti anche su Code Engine.
I costrutti Kubernetes, come le distribuzioni, vengono eseguiti su Code Engine se non utilizzano funzionalità a livello di cluster, come le politiche di sicurezza. Code Engine è nell'ambito di ciò che può essere eseguito in uno spazio dei nomi Kubernetes.

Code Engine non supporta risorse OpenShift-specific o altre piattaforme di orchestrazione di container, come Docker Swarm o Compose Swarm.

Installazione dell'interfaccia a riga di comando di Kubernetes

Per installare la CLI di “ Kubernetes ”, scaricare e installare la CLI di “ kubectl ”.

Accertarsi di aggiungere il file binario kubectl alla variabile di ambiente PATH del sistema.

Interazione con API Kubernetes

Per interagire con il tuo progetto dall'interfaccia riga di comando Kubernetes, kubectl o con Knative, kn devi configurare il tuo ambiente per interagire con l'API Kubernetes di Code Engine.

Prima di iniziare

È necessario creare il progetto e il progetto deve essere nello stato active.
Installa la CLI Kubernetes(kubectl) e la CLI Knative(kn).

Puoi configurare il tuo ambiente nei seguenti modi.

È possibile aggiungere l'opzione --kubecfg al comando project select. Ad esempio,
```
ibmcloud ce project select --name PROJECT_NAME --kubecfg
```

È possibile esportare direttamente il file kubeconfig. Eseguire il comando ibmcloud ce project current per trovare il progetto che si sta attualmente destinando. Questo comando restituisce anche il comando export per il file kubeconfig. Ad esempio,

ibmcloud ce project current

Output di esempio

Getting the current project context...
OK
Name:       myproject
ID:         01234567-abcd-abcd-abcd-abcdabcd1111
Subdomain:  aabon2dfwa0
Domain:     us-south.codeengine.appdomain.cloud
Region:     us-south
Kubectl Context:  4svg40kna19
Kubernetes Config:
Context:             aabon2dfwa0
Environment Variable: export KUBECONFIG=/user/myusername/.bluemix/plugins/code-engine/myproject-01234567-abcd-abcd-abcd-abcdabcd1111.yaml

Quindi, copiare il comando di esportazione, incollarlo nella CLI (command - line interface) ed eseguirlo.

Verificare che il proprio ambiente sia impostato correttamente eseguendo il comando kubectl config.

kubectl config current-context

Se il contesto è impostato correttamente, l'output corrisponde al valore Kubectl Context del progetto. Ad esempio, se il valore Kubectl Context del progetto è 4svg40kna19, il comando restituisce 4svg40kna19.

Per ulteriori informazioni su " Kubernetes " e sul suo funzionamento con l'architettura " Code Engine ", consultare la guida "Informazioni sull'architettura " Code Engine " e sull'isolamento dei carichi di lavoro ".

Autorizzazioni di accesso richieste per utilizzare l'API Kubernetes

Dopo aver configurato il tuo ambiente, puoi interagire con le API Kubernetes. È necessario disporre del corretto livello di autorizzazione per attività specifiche. Questi ruoli sono impostati in Identity and Access Management. Vedi Ruoli del servizioIBM Cloud.

AutoritàKubernetes
Risorsa	Ruolo gestore	Ruolo scrittore	Ruolo lettore
`serviceaccounts`	`get`, `list`, `watch`	`get`, `list`, `watch`	Nessuno
`secrets`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	Nessuno
`configmaps`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	Nessuno
`events`	`get`, `list`, `watch`	`get`, `list`, `watch`	Nessuno
`pods/log`	`get`, `list`, `watch`	`get`, `list`, `watch`	`get`, `list`, `watch`
`pods`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`
`services`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`
`pods/exec`	`create`	`create`	Nessuno
`pods/portforward`	`create`	`create`	Nessuno
`pods/attach`	`create`	Nessuno	Nessuno
`pods/status`	`get`, `list`	`get`, `list`	Nessuno
`resourcequotas`	`get`, `list`, `watch`	`get`, `list`, `watch`	ottenere, elencare, guardare
`limitranges`	`get`, `list`, `watch`	`get`, `list`, `watch`	Nessuno
`deployments`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`, `create`, `delete`, `patch`, `apply`	`get`, `list`, `watch`
`daemonset`	`get`, `list`, `watch`	`get`, `list`, `watch`	`get`, `list`, `watch`
`pods.metrics.k8s.io`	elenco	elenco	elenco

Richiamo della configurazione di Kubernetes

Puoi richiamare la configurazione Kubernetes con la API REST o la CLI Code Engine.

Richiama la tua configurazione Kubernetes con l'API REST

Per richiamare la configurazione di Kubernetes con l'API REST,

Autenticati con IBM Cloud® Identity and Access Management (IAM) per ricevere un token di accesso IAM.
Esegui una query del catalogo IBM Cloud e del controller di risorse IBM Cloud per ricevere un GUID per il progetto.
Utilizza l'API IBM Cloud Code Engine per ricevere una configurazione Kubernetes.

Autentica con Cloud Identity and Access Management

Crea il tuo token di accesso IAM IBM Cloud effettuando una richiesta POST a https://iam.cloud.ibm.com/identity/token.

Determina il GUID del tuo progetto Code Engine

Determina il GUID del tuo progetto Code Engine eseguendo la query del catalogo IBM Cloud e del IBM Cloud. Poiché questo GUID non cambia, è necessario eseguire questa procedura una sola volta. Se già conosci il tuo GUID del progetto Code Engine, puoi ignorare questo passo.

Per utilizzare la CLI Code Engine per rilevare il GUID del progetto Code Engine, completa la seguente procedura.

Accedi a IBM Cloud e seleziona una regione, account e gruppo di risorse.
```
ibmcloud login target -r REGION -c ACCOUNT_ID -g RESOURCE_GROUP
```

Esegui il ibmcloud resource comando.

ibmcloud resource service-instances --service-name codeengine --long

Identifica l'istanza del servizio che rappresenta il tuo progetto Code Engine e determina il GUID dall'output.

Per utilizzare l'API REST per rilevare il GUI del progetto Code Engine, completa la seguente procedura.

Prima di iniziare, è necessario disporre del access_token del passo precedente.

Utilizza il seguente metodo API del catalogo IBM Cloud: Restituisce le voci di catalogo principali.

Output di esempio
```
curl -X GET \
  'https://globalcatalog.cloud.ibm.com/api/v1?include=*&q=name:codeengine+active:true' \
  -H 'Authorization: Bearer ACCESS_TOKEN'
```
Identificare l'ID risorsa univoco nell'elenco di risorse. Il nome del campo è ID e il percorso JSON è resources[].id.
Esegui una query del controller di risorse IBM Cloud con il metodo dell'API del controller di risorse IBM Cloud Ottieni un elenco di tutte le istanze di risorsa. Devi avere il nome del progetto Code Engine, la regione in cui risiede il tuo progetto e l'ID risorsa univoco di Code Engine nel catalogo globale. Utilizza il nome del progetto Code Engine come parametro di query.

Output di esempio
```
curl -X GET \
    'https://resource-controller.cloud.ibm.com/v2/resource_instances?name=MY_PROJECT&resource_id=RESOURCE_ID' \
    -H 'Authorization: Bearer ACCESS_TOKEN'
```
Identifica il progetto Code Engine dalla tua regione nell'elenco dei risultati. Trovare l'output guid da utilizzare nei passi successivi.

Esegui una query dell'API IBM Code Engine

Prima di iniziare, è necessario disporre delle seguenti informazioni.

access_token e refresh_token dei passi precedenti.
guid del tuo progetto Code Engine.
La regione in cui si trova il progetto Code Engine.

Utilizza il metodo API get kubeconfig for the specified project Code Engine per ottenere la configurazione Kubernetes.

Output di esempio

curl -X GET \
    'https://resource-controller.cloud.ibm.com/v2/resource_instances?name=MY_PROJECT&resource_id=RESOURCE_ID' \
    -H 'Authorization: Bearer ACCESS_TOKEN'

Richiama la tua configurazione Kubernetes con la CLI Code Engine

Accedi a IBM Cloud e seleziona una regione, account e gruppo di risorse.
```
ibmcloud login target -r REGION -c ACCOUNT_ID -g RESOURCE_GROUP
```

Crea il tuo progetto " Code Engine ":

ibmcloud ce project create --name PROJECT

Selezionare il progetto Code Engine come contesto corrente e accodare il progetto al file di configurazione Kubernetes predefinito.
```
ibmcloud ce project select --name PROJECT --kubecfg
```

Ora si è pronti a utilizzare i comandi kubectl con il progetto.

Per ulteriori informazioni sull'utilizzo delle API Code Engine, dell'API Kubernetes e di kubectl, vedi i seguenti argomenti:

Definizione risorsa personalizzata (CRD)

Le seguenti sezioni elencano i metodi di definizione della risorsa personalizzata da utilizzare con Code Engine.

Metodi CRD batch

Puoi utilizzare i CRD batch quando Gestione dei lavori e delle esecuzioni di lavoro in Code Engine.

CRD batch per Code Engine
Gruppo	Versione	Tipo
`codeengine.cloud.ibm.com`	v1beta1	`JobDefinition`
`codeengine.cloud.ibm.com`	v1beta1	`JobRun`

Dopo aver richiamato la configurazione di Kubernetes, puoi visualizzare i dettagli CRD batch utilizzando i seguenti metodi.

Utilizzare kubectl explain --api-version='codeengine.cloud.ibm.com/v1beta1' <Kind>.
Scarica Swagger o OpenAPI specifica dei CRD.

Tieni presente che non puoi eliminare un'esecuzione del lavoro senza eliminare anche i pod associati. Qualsiasi tentativo di eliminazione con l'opzione propagationPolicy=Orphan viene rifiutato.

Metodi CRD della funzione

Puoi utilizzare i CRD funzione quando lavori con le funzioni in Code Engine.

CRD funzione per Code Engine
Gruppo	Versione	Tipo
`codeengine.cloud.ibm.com`	v1beta1	`Function`

Utilizzo dei metodi CRD

Puoi utilizzare i CRD di servizio quando lavori con le applicazioni in Code Engine.

Servizi CRD per Code Engine
Gruppo	Versione	Tipo
`serving.knative.dev`	v1	`Configuration`
`serving.knative.dev`	v1	`Revision`
`serving.knative.dev`	v1	`Route`
`serving.knative.dev`	v1	`Service`

Per ulteriori informazioni su questi CRD, vedi Knative Serving API Specification.

Metodi CRD da origine a immagine

Puoi utilizzare i CRD origine - immagine quando Gestione delle build e delle esecuzioni di build in Code Engine.

CRD origine - immagine per Code Engine
Gruppo	Versione	Tipo
`shipwright.io`	v1beta1	`Build`
`shipwright.io`	v1beta1	`BuildRun`

Dopo aver richiamato la configurazione di Kubernetes, puoi visualizzare i dettagli CRD da origine a immagine utilizzando uno dei seguenti metodi.

Utilizzare kubectl explain --api-version='shipwright.io/v1beta1' <KIND>.
Scarica la specifica Swagger o OpenAPI dei CRD.

Metodi CRD di sottoscrizione

Puoi utilizzare i CRD di sottoscrizione quando Gestione delle sottoscrizioni in Code Engine.

Sottoscrizione CRD per Code Engine
Gruppo	Versione	Tipo
`sources.codeengine.cloud.ibm.com`	v1alpha1	`CosSource`
`sources.knative.dev`	v1beta1	`KafkaSource`
`sources.knative.dev`	v1	`PingSource`

Dopo aver richiamato la configurazione Kubernetes, puoi visualizzare i dettagli CRD della sottoscrizione utilizzando uno dei seguenti metodi.

Utilizzare kubectl explain --api-version='sources.knative.dev/<VERSION>' <KIND>.
Scarica la specifica Swagger o OpenAPI dei CRD.