Usando o Kubernetes com o Code Engine

O IBM Cloud® Code Engine foi projetado para que não seja necessário interagir com a tecnologia subjacente em que ele foi construído. No entanto, se você tiver ferramentas existente baseadas em Kubernetes ou Knative, ainda poderá utilizá-las com o Code Engine. O Code Engine suporta as APIs do Kubernetes (e Knative) e seus comandos da CLI. Para obter mais informações sobre o Knative, consulte Usando o Knative com Code Engine.

Se você decidir usar Kubernetes com Code Engine, leve em consideração as seguintes informações:

A maioria dos contêineres ou pods que são executados em Kubernetes também são executados noCode Engine.
As construções de Kubernetes, como as implementações, serão executadas no Code Engine se elas não usarem recursos de todo o cluster, como as políticas de segurança. O Code Engine tem escopo definido para o que pode ser executado em um namespace do Kubernetes.

O Code Engine não suporta recursos específicos do OpenShift ou outras plataformas de orquestração de contêiner, como Docker Swarm ou Compose Swarm.

Instalando a interface da linha de comandos do Kubernetes

Para instalar a CLI do Kubernetes, baixe e instale a CLI do kubectl .

Certifique-se de incluir o binário kubectl à variável de ambiente PATH do seu sistema.

Interagindo com a API do Kubernetes

Para interagir com o seu projeto por meio da interface da linha de comandos do Kubernetes, kubectl, ou com o Knative, kn deve-se configurar seu ambiente para interagir com a API de Kubernetes do Code Engine.

Antes de Iniciar

Deve-se criar o projeto e ele deve ter o status active.
Instale a CLI do Kubernetes (kubectl) e a CLI do Knative (kn).

É possível configurar seu ambiente das maneiras a seguir.

É possível incluir a opção --kubecfg no comando project select. Por exemplo,
```
ibmcloud ce project select --name PROJECT_NAME --kubecfg
```

É possível exportar o arquivo kubeconfig diretamente. Execute o comando ibmcloud ce project current para localizar o projeto que você está visando atualmente. Este comando também retorna o comando export para seu arquivo kubeconfig. Por exemplo,

ibmcloud ce project current

Saída de exemplo

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

Em seguida, copie o comando de exportação, cole-o na interface da linha de comandos e execute-o.

Verifique se seu ambiente está configurado corretamente executando o comando kubectl config.

kubectl config current-context

Se o contexto estiver configurado corretamente, a saída corresponderá ao valor Kubectl Context de seu projeto. Por exemplo, se o valor Kubectl Context de seu projeto for 4svg40kna19, o comando retornará 4svg40kna19.

Para obter mais informações sobre o Kubernetes e como ele funciona com a arquitetura do Code Engine, consulte Aprendendo sobre a arquitetura e o isolamento de carga de trabalho do Code Engine.

Autoridades de acesso necessárias para trabalhar com a API do Kubernetes

Depois de configurar seu ambiente, é possível interagir com a API do Kubernetes. Deve-se ter o nível correto de autoridade para tarefas específicas. Essas funções são configuradas em Gerenciamento de acesso e de identidade Consulte Funções de serviço do IBM Cloud.

AutoridadesKubernetes
Recurso	Função Gerenciador	Função Gravador	Função Leitor
`serviceaccounts`	`get`, `list`, `watch`	`get`, `list`, `watch`	Nenhum
`secrets`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	Nenhum
`configmaps`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	`get`, `list`, `watch`, `create`, `delete`, `update`, `patch`, `apply`, `edit`	Nenhum
`events`	`get`, `list`, `watch`	`get`, `list`, `watch`	Nenhum
`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`	Nenhum
`pods/portforward`	`create`	`create`	Nenhum
`pods/attach`	`create`	Nenhum	Nenhum
`pods/status`	`get`, `list`	`get`, `list`	Nenhum
`resourcequotas`	`get`, `list`, `watch`	`get`, `list`, `watch`	get, list, watch
`limitranges`	`get`, `list`, `watch`	`get`, `list`, `watch`	Nenhum
`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`	lista	lista	lista

Recuperando sua configuração do Kubernetes

É possível recuperar sua configuração do Kubernetes com a API REST ou a Code Engine CLI.

Recuperar sua configuração do Kubernetes com a API de REST

Para recuperar sua configuração do Kubernetes com a API de REST,

Autentique-se com o IBM Cloud® Identity and Access Management (IAM) para receber um token de acesso do IAM.
Consulte o catálogo da IBM Cloud e o Controlador de recurso da IBM Cloud para receber um GUID para o seu projeto.
Use a API do IBM Cloud Code Engine para receber uma configuração do Kubernetes.

Autentique-se com o Cloud Identity and Access Management

Crie seu IBM Cloud token de acesso do IAM fazendo uma solicitação POST para https://iam.cloud.ibm.com/identity/token.

Determine o GUID do seu projeto do Code Engine

Determine o GUID de seu projeto do Code Engine consultando o catálogo da IBM Cloud e a IBM Cloud. Como esse GUID não muda, é necessário executar essa etapa apenas uma vez. Se você já souber seu GUID do projeto do Code Engine, será possível ignorar esta etapa.

Para usar a CLI do Code Engine para descobrir o GUID de seu projeto Code Engine, conclua as etapas a seguir.

Efetue login no IBM Cloud e destine uma região, uma conta e um grupo de recursos.
```
ibmcloud login target -r REGION -c ACCOUNT_ID -g RESOURCE_GROUP
```

Execute o comando ibmcloud resource.

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

Identifique a instância de serviço que representa seu projeto do Code Engine e determine o GUID por meio da saída.

Para usar a API REST para descobrir o GUID de seu projeto Code Engine, conclua as etapas a seguir.

Antes de começar, deve-se ter o access_token da etapa anterior.

Use o método da API do catálogo IBM Cloud a seguir: Retorna entradas do catálogo pai.

Saída de exemplo
```
curl -X GET \
  'https://globalcatalog.cloud.ibm.com/api/v1?include=*&q=name:codeengine+active:true' \
  -H 'Authorization: Bearer ACCESS_TOKEN'
```
Identifique o ID de recurso exclusivo na lista de recursos. O nome do campo é ID e o caminho de JSON é resources[].id.
Consulte o controlador de recursos IBM Cloud utilizando o método da API do controlador de recursos IBM Cloud: [Get a list of all resource instances](https://cloud.ibm.com/apidocs/resource-controller/resource-controller#list-resource-instances){: external}. Deve-se ter o nome do projeto do Code Engine, a região na qual ele reside e o ID de recurso exclusivo do Code Engine no catálogo global. Use o nome de seu projeto do Code Engine como o parâmetro de consulta.

Saída de exemplo
```
curl -X GET \
    'https://resource-controller.cloud.ibm.com/v2/resource_instances?name=MY_PROJECT&resource_id=RESOURCE_ID' \
    -H 'Authorization: Bearer ACCESS_TOKEN'
```
Identifique o projeto do Code Engine de sua região na lista de resultados. Localize a saída guid para usar nas próximas etapas.

Consultar a API do IBM Code Engine

Antes de começar, deve-se ter as informações a seguir.

O access_token e o refresh_token de etapas anteriores.
O guid de seu projeto do Code Engine.
A região na qual seu projeto do Code Engine está localizado.

Use o get kubeconfig for the specified projectCode Engine método da API para obter a configuração do Kubernetes.

Saída de exemplo

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

Recupere sua configuração do Kubernetes usando a CLI do Code Engine

Efetue login no IBM Cloud e destine uma região, uma conta e um grupo de recursos.
```
ibmcloud login target -r REGION -c ACCOUNT_ID -g RESOURCE_GROUP
```

Crie o seu projeto do Code Engine:

ibmcloud ce project create --name PROJECT

Selecione seu projeto do Code Engine como o contexto atual e anexe o projeto ao arquivo de configuração padrão do Kubernetes.
```
ibmcloud ce project select --name PROJECT --kubecfg
```

Agora você está pronto para usar os comandos kubectl com o seu projeto.

Para obter mais informações sobre o uso de APIs do Code Engine, da API do Kubernetes e do kubectl, consulte os tópicos a seguir,

Definição de recurso customizado (CRD)

As seções a seguir listam os métodos de definição de recurso customizado a serem usados com o Code Engine.

Métodos CRD em lote

É possível usar CRDs em lote quando o Trabalhando com tarefas e execuções de tarefas no Code Engine

CRDs em lote para Code Engine
Grupo	Versão	Tipo
`codeengine.cloud.ibm.com`	v1beta1	`JobDefinition`
`codeengine.cloud.ibm.com`	v1beta1	`JobRun`

Depois de recuperar a configuração do Kubernetes, é possível visualizar detalhes do CRD em lote usando os métodos a seguir.

Use o kubectl explain --api-version='codeengine.cloud.ibm.com/v1beta1' <Kind>.
Baixe a especificação Swagger ou a especificação “ OpenAPI ” dos CRDs.

Observe que não é possível excluir uma execução da tarefa sem também excluir quaisquer pods associados. Qualquer tentativa de excluir com a opção propagationPolicy=Orphan é rejeitada.

Métodos CRD de função

É possível usar CRDs de função quando Trabalhando com funções no Code Engine.

CRDs de Função para Code Engine
Grupo	Versão	Tipo
`codeengine.cloud.ibm.com`	v1beta1	`Function`

Entregando métodos CRD

É possível usar CRDs de serviço quando Trabalhando com aplicativos no Code Engine....

Entregando CRDs para Code Engine
Grupo	Versão	Tipo
`serving.knative.dev`	v1	`Configuration`
`serving.knative.dev`	v1	`Revision`
`serving.knative.dev`	v1	`Route`
`serving.knative.dev`	v1	`Service`

Para obter mais informações sobre esses CRDs, consulte a Especificação da API do Knative Serving.

Métodos CRD de origem para imagem

É possível usar CRDs de origem para imagem quando Trabalhar com compilações e execuções de compilação no Code Engine

CRDs de origem para imagem para Code Engine
Grupo	Versão	Tipo
`shipwright.io`	v1beta1	`Build`
`shipwright.io`	v1beta1	`BuildRun`

Depois de recuperar a configuração do Kubernetes, é possível visualizar os detalhes do CRD de origem para imagem usando um dos métodos a seguir.

Use o kubectl explain --api-version='shipwright.io/v1beta1' <KIND>.
Baixe a especificação Swagger ou OpenAPI dos CRDs.

Métodos de CRD de assinatura

É possível usar CRDs de assinatura quando Trabalhando com assinaturas no Code Engine.

CRDs de assinatura para Code Engine
Grupo	Versão	Tipo
`sources.codeengine.cloud.ibm.com`	v1alpha1	`CosSource`
`sources.knative.dev`	v1beta1	`KafkaSource`
`sources.knative.dev`	v1	`PingSource`

Depois de recuperar a configuração do Kubernetes, será possível visualizar os detalhes do CRD de assinatura usando um dos métodos a seguir.

Use o kubectl explain --api-version='sources.knative.dev/<VERSION>' <KIND>.
Baixe a especificação Swagger ou OpenAPI dos CRDs.