Esta página foi traduzida pela API Cloud Translation.

Usar certificados SSL geridos pela Google

Autopilot Padrão

Esta página mostra como pode usar certificados SSL geridos pela Google para o Ingress seguro no GKE. Aprende a usar o serviço de gestão de certificados automatizado da Google para simplificar a encriptação HTTPS das suas aplicações.

Estes certificados são certificados de validação de domínio (DV) que a Google aprovisiona, renova e gere para os seus nomes de domínios. Estes certificados não demonstram a sua identidade individual ou organizacional.

Esta página destina-se a especialistas em redes e especialistas em segurança que planeiam e implementam a segurança de rede, e que desenvolvem e mantêm políticas de segurança. Para saber mais sobre as funções comuns e as tarefas de exemplo que referimos no Google Cloud conteúdo, consulte Funções e tarefas comuns de utilizador do GKE.

Antes de ler esta página, certifique-se de que tem conhecimentos práticos do GKE e uma boa compreensão das redes e da segurança de rede.

Para saber como criar certificados geridos pela Google com o Google Cloud, consulte o artigo Certificados geridos pela Google.

Criar um Ingress com um certificado gerido pela Google

Para configurar um certificado SSL gerido pela Google e associá-lo a um Ingress, tem de:

Crie um objeto ManagedCertificate no mesmo espaço de nomes que o Ingress.
Associe o objeto ManagedCertificate a um Ingress adicionando a anotação networking.gke.io/managed-certificates ao Ingress. Esta anotação é uma lista separada por vírgulas de objetos ManagedCertificate.

Limitações

Os certificados geridos pela Google são menos flexíveis do que os certificados que obtém e gere por si. Os certificados geridos pela Google suportam até 100 domínios sem carateres universais. Ao contrário dos certificados autogeridos, os certificados geridos pela Google não suportam domínios com carateres universais.

Se precisar de certificados autogeridos ou já tiver certificados SSL que queira configurar no seu Ingress, consulte o artigo Configurar HTTPS (TLS) entre o cliente e o balanceador de carga.

O número e o tipo de certificados suportados por um Ingress são definidos pelos limites dos certificados SSL geridos pela Google.

As atualizações em certificados geridos pela Google não são suportadas. Para mais informações, consulte o artigo Atualize manualmente um certificado gerido pela Google.

Se o certificado for revogado diretamente junto da autoridade de certificação, a Google não roda automaticamente o certificado. Tem de eliminar o ManagedCertificate e criar um novo.

Pré-requisitos

Tem de ser proprietário do nome do domínio. O nome do domínio não pode ter mais de 63 carateres. Pode usar o Google Domains ou outra entidade de registo.
Se usar um cluster padrão do GKE, o suplemento HttpLoadBalancing tem de estar ativado.
O seu ingressClassName tem de ser "gce".
Tem de aplicar os recursos Ingress e ManagedCertificate no mesmo projeto e espaço de nomes.
Crie um endereço IP externo reservado (estático). Reservar um endereço IP estático garante que este permanece seu, mesmo que elimine o Ingress. Se não reservar um endereço IP, este pode mudar, o que requer a reconfiguração dos registos de DNS do seu domínio. Use a Google Cloud CLI ou a Google Cloud consola para criar um endereço IP reservado.
gcloud
Para criar um endereço IP reservado, execute o seguinte comando:
```
gcloud compute addresses create ADDRESS_NAME --global
```
Substitua ADDRESS_NAME pelo nome do endereço IP reservado que está a criar.

Para encontrar o endereço IP estático que criou, execute o seguinte comando:
```
gcloud compute addresses describe ADDRESS_NAME --global
```
O resultado é semelhante ao seguinte:
```
address: 203.0.113.32
...
```
Consola
Para criar um endereço IP reservado, siga estes passos:
1. Aceda à página Endereços IP externos na Google Cloud consola.
  
  Aceda a Endereços IP externos
2. Especifique um nome para o endereço IP (por exemplo, example-ip-address).
3. Especifique se quer um endereço IPv4 ou IPv6.
4. Selecione a opção Global para Tipo.
5. Clique em Reservar. O endereço IP é apresentado na coluna Endereço externo.
Config Connector
Nota: este passo requer o Config Connector. Siga as instruções de instalação para instalar o Config Connector no seu cluster.
apiVersion: compute.cnrm.cloud.google.com/v1beta1 kind: ComputeAddress metadata: name: example-ip-address spec: location: global
Para implementar este manifesto, transfira-o para o seu computador como compute-address.yaml e execute:
```
kubectl apply -f compute-address.yaml
```

Configurar um certificado gerido pela Google

Crie um objeto ManagedCertificate. Este recurso especifica os domínios para o certificado SSL. Os domínios com carateres universais não são suportados.

O manifesto seguinte descreve um objeto ManagedCertificate. Guarde o manifesto como managed-cert.yaml.
```
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: managed-cert
spec:
  domains:
    - FQDN_1
    - FQDN_2
```
Substitua o seguinte:
- FQDN_1, FQDN_2: Nomes de domínios totalmente qualificados que detém. Por exemplo, example.com e www.example.com.
Aplique o manifesto ao cluster:
```
kubectl apply -f managed-cert.yaml
```

Crie um serviço do tipo NodePort para expor a sua aplicação à Internet.

O manifesto seguinte descreve um serviço do tipo NodePort. Guarde o manifesto como mc-service.yaml.

apiVersion: v1
kind: Service
metadata:
  name: mc-service
spec:
  selector:
    app: mc-service
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080

Aplique o manifesto ao cluster:
```
kubectl apply -f mc-service.yaml
```
Nota: para que este objeto ManagedCertificate se torne Active, tem de o anexar a um Ingress. O ManagedCertificate não tem de já estar Active para o poder anexar a um Ingress.

Crie um Ingress.

O manifesto seguinte descreve um Ingress que usa o ManagedCertificate que criou. Guarde o manifesto como managed-cert-ingress.yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: managed-cert-ingress
  annotations:
    kubernetes.io/ingress.global-static-ip-name: ADDRESS_NAME
    networking.gke.io/managed-certificates: managed-cert
    kubernetes.io/ingress.class: "gce"  # Updated annotation
spec:
  defaultBackend:
    service:
      name: mc-service
      port:
        number: SERVICE_PORT

Substitua o seguinte:

ADDRESS_NAME: o nome do seu endereço IP reservado.
SERVICE_PORT: o valor de ports.port no seu manifesto de serviço.

Aplique o manifesto ao cluster:
```
kubectl apply -f managed-cert-ingress.yaml
```
Nota: o aprovisionamento do balanceador de carga e do certificado gerido, bem como o início da utilização do novo certificado por parte do balanceador de carga, podem demorar várias horas. Google Cloud Para mais informações, consulte o artigo Implemente um certificado gerido pela Google com autorização do equilibrador de carga.
Obtenha o endereço IP do balanceador de carga:
```
kubectl get ingress
```
O resultado é semelhante ao seguinte:
```
NAME                 HOSTS       ADDRESS         PORTS     AGE
managed-cert-ingress   *         203.0.113.32     80       54s
```
O endereço IP do equilibrador de carga é apresentado na coluna ADDRESS. Se estiver a usar um endereço IP estático reservado, esse será o endereço do balanceador de carga.

Se a morada não for apresentada, aguarde até que o Ingress termine a configuração.
Configure os registos DNS dos seus domínios para apontarem para o endereço IP do equilibrador de carga. Se usar o Cloud DNS, consulte o artigo Gerir registos para ver detalhes.

Nota: tem de aguardar que os registos de DNS que configurou sejam propagados antes de continuar.
Aguarde pela conclusão do aprovisionamento do certificado gerido pela Google. Esta ação pode demorar até 60 minutos. Pode verificar o estado do certificado através do seguinte comando:
```
kubectl describe managedcertificate managed-cert
```
O resultado é semelhante ao seguinte:
```
Name:         managed-cert
Namespace:    default
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         ManagedCertificate
(...)
Spec:
 Domains:
   FQDN_1
   FQDN_2
Status:
 CertificateStatus: Active
(...)
```
O valor do campo Status.CertificateStatus indica que o certificado foi aprovisionado. Se Status.CertificateStatus não for Active, o certificado ainda não foi aprovisionado.
Pode verificar os eventos num Ingress através do seguinte comando:
```
kubectl describe ingress INGRESS_NAME
```
Substitua INGRESS_NAME pelo nome do seu Ingress.
Verifique se o SSL está a funcionar visitando os seus domínios com o prefixo https://. O seu navegador indica que a ligação é segura e pode ver os detalhes do certificado.

Migrar para certificados geridos pela Google a partir de certificados autogeridos

Quando migrar um Ingress da utilização de certificados SSL autogeridos para certificados SSL geridos pela Google, não elimine nenhum certificado SSL autogerido antes de os certificados SSL geridos pela Google estarem ativos. Depois de os certificados SSL geridos pela Google serem aprovisionados com êxito, ficam automaticamente ativos. Quando os certificados SSL geridos pela Google estão ativos, pode eliminar os seus certificados SSL autogeridos.

Siga estas instruções para migrar de certificados SSL autogeridos para certificados SSL geridos pela Google.

Adicione um novo certificado gerido pela Google ao Ingress, conforme descrito na secção Configurar um certificado gerido pela Google.
Aguarde até que o estado do recurso de certificado gerido pela Google seja Ativo. Verifique o estado do certificado com o seguinte comando:
```
kubectl describe managedcertificate managed-cert
```
Quando o estado for Active, atualize o Ingress para remover as referências ao certificado autogerido.

Remover um certificado gerido pela Google

Para remover um certificado gerido pela Google do seu cluster, tem de eliminar o objeto ManagedCertificate e remover a anotação Ingress que faz referência ao mesmo.

Elimine o objeto ManagedCertificate:

kubectl delete -f managed-cert.yaml

O resultado é semelhante ao seguinte:

managedcertificate.networking.gke.io "managed-cert" deleted

Remova a anotação do Ingress:

kubectl annotate ingress managed-cert-ingress networking.gke.io/managed-certificates-

Repare no sinal de subtração, -, no final do comando.

Liberte o endereço IP estático que reservou para o seu balanceador de carga.

Pode usar a Google Cloud CLI, a Google Cloud consola ou o Config Connector para libertar um endereço IP reservado.
gcloud
Use o seguinte comando para libertar o endereço IP reservado:
```
gcloud compute addresses delete ADDRESS_NAME --global
```
Substitua ADDRESS_NAME pelo nome do endereço IP.
Consola
Para libertar o endereço IP reservado, siga estes passos:
1. Aceda à página Endereços IP externos na Google Cloud consola.
  
  Aceda a Endereços IP externos
2. Selecione a caixa de verificação junto ao endereço IP que quer libertar.
3. Clique em Retirar endereço IP.
Config Connector
Nota: este passo requer o Config Connector. Siga as instruções de instalação para instalar o Config Connector no seu cluster.
apiVersion: compute.cnrm.cloud.google.com/v1beta1 kind: ComputeAddress metadata: name: example-ip-address spec: location: global
Para implementar este manifesto, transfira-o para o seu computador como compute-address.yaml e execute:
```
kubectl delete -f compute-address.yaml
```

Resolução de problemas

Esta secção fornece informações sobre como resolver problemas com certificados geridos pela Google.

Verifique os eventos em `ManagedCertificate` e os recursos do Ingress

Se exceder o número de certificados permitidos, é adicionado um evento com o motivo TooManyCertificates ao ManagedCertificate. Pode verificar os eventos num objeto ManagedCertificate através do seguinte comando:

kubectl describe managedcertificate CERTIFICATE_NAME

Substitua CERTIFICATE_NAME pelo nome do seu ManagedCertificate.

Se anexar um ManagedCertificate inexistente a um Ingress, é adicionado um evento com o motivo MissingCertificate ao Ingress. Pode verificar os eventos num Ingress através do seguinte comando:

kubectl describe ingress INGRESS_NAME

Substitua INGRESS_NAME pelo nome do seu Ingress.

Certificado gerido não aprovisionado quando o domínio é resolvido para endereços IP de vários equilibradores de carga

Quando o seu domínio é resolvido para endereços IP de vários balanceadores de carga (vários objetos Ingress), deve criar um único objeto ManagedCertificate e anexá-lo a todos os objetos Ingress. Se, em alternativa, criar muitos objetos ManagedCertificate e anexar cada um deles a um Ingress separado, a autoridade de certificação pode não conseguir validar a propriedade do seu domínio e alguns dos seus certificados podem não ser aprovisionados. Para que a validação seja bem-sucedida, o certificado tem de estar visível em todos os endereços IP para os quais o seu domínio é resolvido.

Especificamente, quando o seu domínio é resolvido para um endereço IPv4 e um endereço IPv6 que estão configurados com objetos Ingress diferentes, deve criar um único objeto ManagedCertificate e anexá-lo a ambos os Ingresses.

Comunicação interrompida entre os certificados geridos pela Google e o Ingress

Os certificados geridos comunicam com o Ingress através da anotação ingress.gcp.kubernetes.io/pre-shared-cert. Pode interromper esta comunicação se, por exemplo:

Execute um processo automatizado que limpe a anotação.ingress.gcp.kubernetes.io/pre-shared-cert
Armazene uma captura instantânea do Ingress e, em seguida, elimine e restaure o Ingress a partir da captura instantânea. Entretanto, um recurso SslCertificate listado na anotação ingress.gcp.kubernetes.io/pre-shared-cert pode ter sido eliminado. O Ingress não funciona se faltarem certificados anexados ao mesmo.

Se a comunicação entre os certificados geridos pela Google e o Ingress for interrompida, elimine o conteúdo da anotação ingress.gcp.kubernetes.io/pre-shared-cert e aguarde que o sistema reconcilie. Para evitar a recorrência, certifique-se de que a anotação não é modificada nem eliminada inadvertidamente.

Erros de validação ao criar um certificado gerido pela Google

As definições de ManagedCertificate são validadas antes de o objeto ManagedCertificate ser criado. Se a validação falhar, o objeto ManagedCertificate não é criado e é apresentada uma mensagem de erro. As diferentes mensagens de erro e motivos são explicados da seguinte forma:

`spec.domains in body should have at most 100 items`

O seu manifesto ManagedCertificate lista mais de 100 domínios no campo spec.domains. Os certificados geridos pela Google só suportam até 100 domínios.

`spec.domains in body should match '^(([a-zA-Z0-9]+|[a-zA-Z0-9][-a-zA-Z0-9][a-zA-Z0-9])\.)+[a-zA-Z][-a-zA-Z0-9][a-zA-Z0-9]\.?$'`

Especificou um nome do domínio inválido ou um nome do domínio com carateres universais no campo spec.domains. O objeto ManagedCertificate não suporta domínios com carateres universais (por exemplo, *.example.com).

`spec.domains in body should be at most 63 chars long`

Especificou um nome de domínio demasiado longo. Os certificados geridos pela Google suportam nomes de domínio com, no máximo, 63 carateres.

Atualizar manualmente um certificado gerido pela Google

Para atualizar manualmente o certificado de modo que o certificado do domínio antigo continue a funcionar até que o certificado do novo domínio seja aprovisionado, siga estes passos:

Crie um ManagedCertificate para o novo domínio.
Adicione o nome do ManagedCertificate à anotação networking.gke.io/managed-certificates no Ingress através de uma lista separada por vírgulas. Não remova o nome do certificado antigo.
Aguarde até que o ManagedCertificate fique ativo.
Desassocie o certificado antigo do Ingress e elimine-o.

Quando cria um ManagedCertificate, Google Cloud cria um certificado SSL gerido pela Google. Não pode atualizar este certificado. Se atualizar o ManagedCertificate, Google Cloud elimina e recria o certificado SSL gerido pela Google.

Para fornecer um Ingress encriptado HTTPS seguro para os seus clusters do GKE, consulte o exemplo Ingress seguro.

O que se segue?

Saiba mais sobre os certificados geridos pela Google.
Saiba como configurar um Application Load Balancer externo com Ingress.
Saiba como usar vários certificados SSL com balanceadores de carga de aplicações externos com entrada.
Implemente um acesso seguro.