Versão 2.4

Versões disponíveis

2.11 - Versão mais recente
2.10
2.9
2.7 - EOL/não compatível
2.6 - EOL/não compatível
2.8 - EOL/não compatível
2.5 - EOL/não compatível
2.4 - EOL/não compatível
2.3 - EOL/não compatível
2.2 - EOL/não compatível
2.1 - EOL/não compatível

Atualizar o Kf

Este documento descreve como atualizar uma instalação atual do Kf e as dependências dela.

Como parte do procedimento de upgrade, você garante que a instalação do Kf usa a versão mais recente do operador Kf:

Confirme se a versão atual do Kf pode fazer upgrade para o Kf v2.4.1.
Faça upgrade para o Kf v2.4.1.
Faça upgrade das dependências (se necessário).

Antes de começar

Você precisará dos seguintes itens:

Um cluster com o Kf instalado.
Acesso a uma máquina com gcloud, kf e kubectl instalados.

Como se preparar para o upgrade

Conectar-se ao cluster de destino

gcloud container clusters get-credentials CLUSTER_NAME \
 --zone CLUSTER_ZONE \
 --project CLUSTER_PROJECT_ID

Confirmar se a CLI atual do Kf e as versões do servidor correspondem

Execute o comando kf debug e verifique se a CLI do Kf e o servidor Kf têm a mesma versão.

A versão da CLI aparece em Kf Client.
A versão do servidor Kf aparece em kf["app.kubernetes.io/version"].

$ kf debug
...
Version:
  Kf Client:                        v2.3.2
  Server version:                   v1.20.6-gke.1000
  kf["app.kubernetes.io/version"]:  v2.3.2
...

Se os valores do cliente e do servidor Kf não corresponderem, mas a versão do servidor for v2.3.x, instale a CLI do Kf v2.4.1 antes de continuar.

Se o valor do servidor Kf for mais antigo que v2.3.x, primeiro faça um upgrade incremental para o Kf v2.3.x antes de continuar.

Confirmar se o Kf está normal antes de fazer upgrade

Execute kf doctor para verificar o estado do cluster. Todos os testes devem ser aprovados antes de continuar.

$ kf doctor
...
=== RUN doctor/user
=== RUN doctor/user/ContainerRegistry
--- PASS: doctor/user
   --- PASS: doctor/user/ContainerRegistry
...

Se as mensagens de erro FAIL ou Error: environment failed checks aparecerem, siga as orientações do comando kf doctor ou confira o guia de solução de problemas para resolvê-las. Depois execute o comando de novo até ter sucesso.

Fazer backup opcional dos configmaps do Kf em caso de personalizações

Faça um backup do configmap config-defaults executando:

kubectl get configmap config-defaults -o yaml -n kf > config-defaults-backup.yaml

Faça um backup do configmap config-secrets executando:
```
kubectl get configmap config-secrets -o yaml -n kf > config-secrets-backup.yaml
```
Observação: esse backup é apenas para referência e não deve ser aplicado diretamente.

Fazer upgrade do operador Kf

O operador Kf foi lançado como parte das versões 2.4.0:

Se você já instalou o operador Kf como parte da instalação da versão 2.4.0, faça upgrade dele apenas como parte da atualização para 2.4.1.

Consulte Fazer upgrade do operador Kf.
Se você estiver fazendo upgrade da versão 2.3.2, instale a versão 2.4.1 do operador Kf a fim de atualizar para o Kf gerenciado por operador.

Consulte Instalar o operador Kf.

Fazer upgrade do operador Kf atual

O operador Kf faz upgrades para você.

Aplique o yaml do operador:

Observação: esta operação começa imediatamente e não é reversível.
```
kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.4.1/operator.yaml"
```

Instalar o operador Kf pela primeira vez

Execute estas etapas para fazer upgrade para o Kf gerenciado por operador.

Aplique o yaml do operador:

Observação: esta operação começa imediatamente e não é reversível.
```
kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.4.1/operator.yaml"
```
Escolha entre usar os padrões ou reter as personalizações:

Observação: escolha uma das opções. Não conclua as duas.
1. Prepare o kfsystem.yaml para upgrade usando os padrões:
  
  Observação: siga estas etapas se você não fez nenhuma personalização em config-defaults ou config-secrets.
  
  Baixe o arquivo kfsystem.yaml, preencha as variáveis abaixo e execute os comandos no mesmo diretório do arquivo para preparar kfsystem.yaml automaticamente para o upgrade.
```
export CLUSTER_PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_NAME=YOUR_CLUSTER_NAME
export CONTAINER_REGISTRY=YOUR_CLUSTER_COMPUTE_REGION-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}

kubectl apply -f kfsystem.yaml

kubectl patch \
kfsystem kfsystem \
--type='json' \
-p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': true, 'config': {'spaceContainerRegistry': '${CONTAINER_REGISTRY}', 'secrets':{'workloadidentity':{'googleserviceaccount':'${CLUSTER_NAME}-sa', 'googleprojectid':'${CLUSTER_PROJECT_ID}'}}}}}]"
```
2. Prepare o kfsystem.yaml para upgrade enquanto preserva as personalizações:
  
  Observação: siga estas etapas se você fez personalizações em config-defaults ou config-secrets. Será necessário copiá-las manualmente para os campos correspondentes em kfsystem.yaml.
  1. Baixe o arquivo kfsystem.yaml.
  2. Faça um backup do configmap config-defaults executando:
```
kubectl get configmap config-defaults -o yaml -n kf > config-defaults-backup.yaml
```
  3. Faça um backup do configmap config-secrets executando:
```
kubectl get configmap config-secrets -o yaml -n kf > config-secrets-backup.yaml
```
  4. Inspecione os configmaps config-defaults e config-secrets atuais e encontre as configurações correspondentes em kfsystem.yaml.
  5. Copie as configurações atuais de config-secrets e config-defaults. Todas as configurações em config-secrets e config-defaults estão disponíveis em kfsystem.yaml. O campo googleProjectId agora é obrigatório.
  6. O campo wi.googleServiceAccount é a conta de serviço completa em config-secrets, mas para kfsystem, o sufixo precisa ser removido. Por exemplo, ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com passa a ser ${CLUSTER_NAME}-sa em kfsystem.yaml.
  7. Depois que as configurações forem copiadas, altere o campo enabled em kfsystem para true.
  8. Salve as alterações em kfsystem.yaml.
  9. Configure o operador para o Kf:
```
kubectl apply -f kfsystem.yaml
```

Fazer upgrade das dependências do Kf

Faça upgrade do Tekton:

kubectl apply -f "https://storage.googleapis.com/tekton-releases/pipeline/previous/v0.23.0/release.yaml"

Faça upgrade do Cloud Service Mesh:

Observação: se a sua versão do Cloud Service Mesh é mais antiga que 1.9, conclua esta etapa.
1. Siga as etapas no Guia de upgrade do Cloud Service Mesh 1.9.
Faça upgrade do Config Connector.

Observação: o Config Connector é necessário a partir do Kf v2.4.0.
Aviso: não use o método de complemento do GKE para instalar o Config Connector porque ele não é compatível com o Kf. Use estas etapas de instalação personalizadas.
1. Baixe o arquivo .tar necessário do operador do Config Connector:
  
  Observação: mantenha uma cópia do pacote de instalação. Ele é necessário para desinstalar o Config Connector.
2. Extraia o arquivo .tar.
```
tar zxvf release-bundle.tar.gz
```
3. Instale o operador do Config Connector no cluster.
```
kubectl apply -f operator-system/configconnector-operator.yaml
```
4. Configure o operador do Config Connector se estiver instalando o Config Connector pela primeira vez.
  1. Copie o seguinte YAML para um arquivo chamado configconnector.yaml:
    
    Atenção: substitua a variável KF_SERVICE_ACCOUNT_NAME no YAML abaixo com a conta de serviço completa resolvida em ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
```
# configconnector.yaml
apiVersion: core.cnrm.cloud.google.com/v1beta1
kind: ConfigConnector
metadata:
# the name is restricted to ensure that there is only one
# ConfigConnector resource installed in your cluster
name: configconnector.core.cnrm.cloud.google.com
spec:
mode: cluster
googleServiceAccount: "KF_SERVICE_ACCOUNT_NAME" # Replace with the full service account resolved from ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
```
  2. Aplique a configuração ao seu cluster.
```
kubectl apply -f configconnector.yaml
```
5. Verifique se o Config Connector está totalmente instalado antes de continuar.
  - Todos os componentes do Config Connector são executados em um namespace chamado cnrm-system. Execute este comando para verificar se os pods estão prontos:
```
kubectl wait -n cnrm-system --for=condition=Ready pod --all
```
  - Se o Config Connector estiver instalado corretamente, a saída será semelhante a esta:
```
pod/cnrm-controller-manager-0 condition met
```
    Observação: o pod do controlador pode levar vários minutos para ser iniciado.
6. Configure a Identidade da carga de trabalho se estiver instalando o Config Connector pela primeira vez.
```
kubectl annotate serviceaccount \
--namespace cnrm-system \
--overwrite \
cnrm-controller-manager \
iam.gke.io/gcp-service-account=${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
```

Fazer upgrade para a CLI do Kf v2.4.1

Instale a CLI:
Linux
Este comando instala a CLI do Kf para todos os usuários no sistema. Siga as instruções na guia do Cloud Shell para instalá-lo só para você.
```
gcloud storage cp gs://kf-releases/v2.4.1/kf-linux /tmp/kf
chmod a+x /tmp/kf
sudo mv /tmp/kf /usr/local/bin/kf
```
Mac
Este comando instala o kf para todos os usuários no sistema.
```
gcloud storage cp gs://kf-releases/v2.4.1/kf-darwin /tmp/kf
chmod a+x /tmp/kf
sudo mv /tmp/kf /usr/local/bin/kf
```
Cloud Shell
O comando vai instalar o kf na instância do Cloud Shell se você usar bash. Talvez seja necessário mudar as instruções para outros shells.
```
mkdir -p ~/bin
gcloud storage cp gs://kf-releases/v2.4.1/kf-linux ~/bin/kf
chmod a+x ~/bin/kf
echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
source ~/.bashrc
```
Windows
Este comando faz o download de kf no diretório atual. Adicione o arquivo ao caminho se você quiser chamá-lo de outro local que não seja o diretório atual.
```
gcloud storage cp gs://kf-releases/v2.4.1/kf-windows.exe kf.exe
```

Verifique se a CLI do Kf e o servidor Kf têm a mesma versão:

A versão da CLI aparece em Kf Client.
A versão do servidor Kf aparece em kf["app.kubernetes.io/version"].

$ kf debug
...
Version:
  Kf Client:                        v2.4.1
  Server version:                   v1.20.6-gke.1000
  kf["app.kubernetes.io/version"]:  v2.4.1
...

Verificar se o Kf foi atualizado

Se estiver instalando o operador Kf pela primeira vez, confirme a instalação do operador:
```
kubectl get deployment -n appdevexperience appdevexperience-operator
```
Se o operador não aparecer como mostrado na saída de exemplo abaixo, revise as etapas em Instalar o operador Kf pela primeira vez.
```
NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
appdevexperience-operator   1/1     1            1           1h
```
Execute doctor para verificar a integridade da versão recém-instalada:
```
kf doctor --retries=20
```
O comando executará as verificações de cluster várias vezes. É normal haver algumas falhas enquanto os novos controladores são iniciados.

Se o comando falhar com a mensagem Error: environment failed checks, siga as orientações na saída doctor para resolver o problema e repita o comando até que a operação seja bem-sucedida.

Se você fez personalizações em config-defaults ou config-secrets, verifique se elas foram transferidas:

Compare o arquivo config-defaults-backup.yaml com kubectl diff -f config-defaults-backup.yaml para garantir que o cluster ainda esteja configurado corretamente.

Por exemplo, se você manteve todas as alterações da versão antiga do Kf e aprovou o uso de um novo buildpack incluído na próxima versão do Kf:

$ kubectl diff -f config-defaults-backup.yaml
diff -u -N /tmp/LIVE/v1.ConfigMap.kf.config-defaults /tmp/MERGED/v1.ConfigMap.kf.config-defaults
--- /tmp/LIVE/v1.ConfigMap.kf.config-defaults
+++ /tmp/MERGED/v1.ConfigMap.kf.config-defaults
@@ -131,6 +131,8 @@
     enable_route_services: false
   spaceBuildpacksV2: |
-    - name: new_buildpack
-      url: https://github.com/cloudfoundry/new-buildpack
     - name: staticfile_buildpack
       url: https://github.com/cloudfoundry/staticfile-buildpack
     - name: java_buildpack
exit status 1

Se a verificação foi bem-sucedida, significa que o upgrade do cluster foi concluído. Se tiver algum problema, confira as orientações da página de suporte.