Esta documentação se refere à versão mais recente do Knative serving, que usa frotas e o Anthos Service Mesh. Saiba mais.

A versão anterior (Cloud Run for Anthos) foi arquivada, mas a documentação continua disponível para os usuários atuais.

Versões disponíveis

Mais recente
Arquivar

Esta página foi traduzida pela API Cloud Translation.

Como migrar cargas de trabalho para o Knative OSS

Use este guia para migrar as cargas de trabalho para serem executadas na oferta de código aberto do Knative com o Google Kubernetes Engine. Em geral, para migrar suas cargas de trabalho, é preciso instalar o componente Knative Serving em um novo cluster do GKE e, em seguida, reimplantar cada um dos seus serviços nesse cluster do Knative.

Embora o uso, o gerenciamento e o suporte ao Knative de código aberto sejam escolhas e responsabilidades, a migração para o Knative oferece a você a oportunidade de continuar executando suas cargas de trabalho na plataforma do Google Kubernetes Engine.

Diferenças significativas:

O suporte é limitado ao Google Kubernetes Engine. Entre em contato com a comunidade Knative para receber suporte.
A Google Cloud CLI (gcloud) é compatível apenas com o Google Kubernetes Engine. O Knative é compatível com os comandos kubectl e kn. Saiba como instalar o kn

Antes de começar

Você precisa ter acesso a um novo cluster do GKE.
- É possível criar seu novo cluster no mesmo projeto ou em um novo Google Cloud .
- Seu cluster precisa atender aos requisitos do Knative.
- Saiba como criar um cluster:
  - Cluster padrão
  - Cluster particular
É necessário transferir manualmente as configurações do cluster para o novo cluster do Knative, incluindo, entre outros:
Você precisa criar e configurar novos controles de acesso do IAM e do RBAC:
- Configurar o controle de acesso
- Identidade da carga de trabalho

Como instalar o Knative no Google Kubernetes Engine

O Knative oferece várias opções de instalação e camadas de rede que você pode usar. As etapas de instalação do Knative a seguir usam o método do operador Knative e a camada de rede do Istio.

Instale o operador Knative:

Implante o operador no cluster:

kubectl apply -f https://github.com/knative/operator/releases/download/knative-vVERSION/operator.yaml

Substitua VERSION por uma versão do Knative Operator.

Exemplo:

kubectl apply -f https://github.com/knative/operator/releases/download/knative-v1.3.1/operator.yaml

Defina a kubectl CLI para usar o namespace default:

kubectl config set-context --current --namespace=default

Verifique se o operador foi criado com sucesso:

kubectl get deployment knative-operator

Resultado:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
knative-operator   1/1     1            1           6m43s

Instale o componente do Knative Serving:

Crie um arquivo YAML com o seguinte, por exemplo, SERVING_FILENAME.yaml:

apiVersion: v1
kind: Namespace
metadata:
  name: knative-serving
---
apiVersion: operator.knative.dev/v1alpha1
kind: KnativeServing
metadata:
  name: knative-serving
  namespace: knative-serving

Implante o arquivo YAML no cluster:
```
kubectl apply -f SERVING_FILENAME.yaml
```
Substitua SERVING_FILENAME pelo arquivo YAML que você criou.

Instale o Istio com a injeção de arquivo secundário como a camada de rede:

Você tem a opção de executar e configurar uma instalação alternativa do Istio. Veja todas as opções de instalação do Istio no site do Knative. A instalação pode levar mais de 30 minutos.
1. Faça o download do Istio na página de lançamento.
2. Instale o Istio executando o seguinte comando com a sinalização --set hub=gcr.io/istio-release para evitar a limitação de taxa do Docker:
```
istioctl install --set hub=gcr.io/istio-release
```
3. Execute o seguinte comando para ativar a injeção de sidecar:
```
kubectl label namespace default istio-injection=enabled
```
4. Opcional: por padrão, o Istio é instalado no namespace istio-system. Se você quiser configurar um namespace diferente, siga estas etapas:
  1. Para configurar um namespace personalizado para o Istio, anexe os atributos spec.config.istio ao arquivo de configuração SERVING_FILENAME.yaml. Por exemplo:
```
apiVersion: operator.knative.dev/v1alpha1
kind: KnativeServing
metadata:
  name: knative-serving
  namespace: knative-serving
spec:
  # ...
  config:
    istio:
      local-gateway.LOCAL_GATEWAY_NAMESPACE.knative-local-gateway: "knative-local-gateway.ISTIO_NAMESPACE.svc.cluster.local"
```
    Substitua:
    - LOCAL_GATEWAY_NAMESPACE é o namespace em que você instalou o Knative Serving. Padrão: knative-serving
    - ISTIO_NAMESPACE é o namespace em que o Istio está instalado. Padrão: istio-system
  2. Implante o serviço SERVING_FILENAME.yaml atualizado no cluster do Knative:
```
kubectl apply -f SERVING_FILENAME.yaml
```
  3. Verifique a instalação do Istio confirmando que istio-ingressgateway reside no namespace especificado:
```
kubectl get svc istio-ingressgateway -n ISTIO_NAMESPACE
```
    Substitua ISTIO_NAMESPACE pelo namespace em que você instalou o Istio. Padrão: istio-system
    
    Resultado:
```
NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)                                      AGE
istio-ingressgateway   LoadBalancer   10.232.10.190   34.123.5.116   15021:30337/TCP,80:32549/TCP,443:31210/TCP   119m
```

Como migrar um serviço

Para migrar um serviço, implante o arquivo de configuração YAML do serviço no cluster Knative.

Exporte o serviço do Knative serving para um arquivo YAML local executando o seguinte comando:
```
gcloud run services describe SERVICE --format export --namespace NAMESPACE --cluster CLUSTER --platform gke > FILENAME.yaml
```
Substitua:
- SERVICE pelo nome do serviço do Knative serving.
- NAMESPACE pelo namespace em que o serviço está sendo executado.
- CLUSTER pelo nome do cluster em que o serviço está em execução.
- FILENAME por um nome de arquivo exclusivo da sua escolha.
Modifique o arquivo FILENAME.yaml exportado para remover as configurações indesejadas do Knative serving excluindo qualquer um dos seguintes atributos e os valores deles:
- metadata.annotations.kubectl.kubernetes.io/last-applied-configuration
- metadata.managedFields
- spec.template.spec.containers.readinessProbes
- spec.template.spec.enableServiceLinks
  
  Por exemplo, talvez seja necessário remover a seguinte configuração dos atributos spec: > template: > spec: > containers::
```
...
 readinessProbe:
   successThreshold: 1
   tcpSocket: {}
...
```
Implante o arquivo .yaml modificado no cluster do Knative:
```
kubectl apply -f SERVICE.yaml
```
Substitua SERVICE pelo nome do arquivo de configuração do serviço.
Acesse o serviço implantado usando um domínio de teste ou comandos cURL. É possível usar um serviço DNS curinga para testar o acesso externo ao seu serviço. Consulte a seção Como configurar o DNS nos documentos do Knative para ver mais opções.

Para usar o Magic DNS (sslip.io), execute o seguinte comando.

Também é possível usar diretamente sslip.io.
```
kubectl apply -f https://github.com/knative/serving/releases/download/knative-vVERSION/serving-default-domain.yaml
```
Substitua VERSION pela versão do Knative Serving.

Exemplo:
```
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.3.0/serving-default-domain.yaml
```

Como migrar o tráfego para o serviço

Depois de testar os serviços recém-implantados e estar pronto para migrar todo o tráfego de produção, configure o domínio personalizado e atualize os registros DNS com seu registrador. Siga as instruções em Como configurar domínios personalizados.