Como ativar o SSL para o Cloud Endpoints

Talvez seja necessário ativar uma porta SSL no serviço implantado do Endpoints. Por exemplo, quando você usa o recurso de transcodificação do gRPC e quer que o serviço receba solicitações HTTP 1.1 e gRPC na mesma porta. Neste documento, você verá como ativar a porta SSL ao implantar o Extensible Service Proxy (ESP) com o Google Kubernetes Engine e o Kubernetes ou o Compute Engine. Para isso, é recomendado que você já tenha seguido os tutoriais sobre o tipo de serviço e ambiente escolhidos e saber como fazer a implantação sem o SSL.

Certificados e chaves SSL

Para ativar a porta SSL para que ela possa exibir solicitações HTTPS, certifique-se de que os arquivos de certificado e chave SSL tenham o nome de arquivo nginx.key e nginx.crt, respectivamente. Para o teste, você pode gerar um nginx.key e nginx.cert autoassinado usando o OpenSSL.

      openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
            -keyout ./nginx.key -out ./nginx.crt
    

Como ativar o SSL para ESP no Kubernetes

Para ativar a porta SSL para ESP no Kubernetes, siga as seguintes etapas:

  1. Crie um secret do Kubernetes com o certificado e a chave SSL:

      kubectl create secret generic nginx-ssl \
             --from-file=./nginx.crt --from-file=./nginx.key
        
  2. Edite os arquivos de configuração do Kubernetes, por exemplo, esp_echo_gke.yaml, conforme mostrado no snippet a seguir:

    template:
          metadata:
            labels:
              app: esp-echo
          spec:
            volumes:
            - name: nginx-ssl
              secret:
                secretName: nginx-ssl
            containers:
            - name: esp
              image: gcr.io/endpoints-release/endpoints-runtime:1
              args: [
                "--http_port", "8080",
                "--ssl_port", "443",
                "--backend", "127.0.0.1:8081",
                "--service", "SERVICE_NAME",
                "--rollout_strategy", "managed",
              ]
              ports:
                - containerPort: 8080
                - containerPort: 443
              volumeMounts:
              - mountPath: /etc/nginx/ssl
                name: nginx-ssl
                readOnly: true
            - name: echo
              image: gcr.io/endpoints-release/echo:latest
              ports:
                - containerPort: 8081

    Observação: a amostra de configuração exibe as linhas que precisam ser editadas. Para implantar o arquivo no Cloud Endpoints é necessário o arquivo de configuração completo.

  3. Ative os secrets do Kubernetes criados como volumes seguindo as instruções da página de volumes do Kubernetes (em inglês).

  4. Inicie o ESP conforme descrito em Como especificar opções de inicialização para o ESP, mas certifique-se de adicionar a sinalização de inicialização --ssl_port para ativar a porta SSL. A padrão é 443.

  5. Inicie o serviço com o arquivo de configuração atualizado do Kubernetes usando kubectl.

    kubectl apply -f esp_echo_gke.yaml
        

Como ativar o SSL para ESP no Compute Engine

Para ativar o SSL no Compute Engine, primeiro copie a chave e os arquivos crt para a pasta /etc/nginx/ssl da instância do Compute Engine, desta maneira:

  1. Execute o seguinte comando e substitua INSTANCE_NAME pelo nome da instância do Compute Engine:

        gcloud compute scp nginx.* INSTANCE-NAME:
        
  2. Conecte-se à instância usando ssh.

        gcloud compute ssh INSTANCE-NAME
        

  3. Na caixa "VM da instância", crie o diretório e copie os arquivos:

      sudo mkdir -p /etc/nginx/ssl
          sudo cp nginx.* /etc/nginx/ssl/
        

Siga as instruções para o tipo de serviço a implantar com o Docker. Quando você for executar o contêiner do Docker ESP, use este comando:

 sudo docker run --name=esp \
         --detach \
         --publish=443:443 \
         --net=esp_net \
         --volume=/etc/nginx/ssl:/etc/nginx/ssl \
         --link=echo:echo \
         gcr.io/endpoints-release/endpoints-runtime:1 \
         --service=[SERVICE_NAME] \
         --rollout_strategy=managed \
         --backend=echo:8080 \
         --ssl_port=443
    

Ao comparar o comando docker run não SSL à versão SSL dele, você verá as seguintes diferenças:

  • Use --volume para ativar a pasta com a chave e os arquivos CRT no contêiner.
  • Use --ssl_port=443 para informar ao ESP para ativar o SSL na porta 443
  • A sinalização de mapeamento de porta --publish foi alterada.

Teste da porta SSL

Para facilitar o teste, defina as seguintes variáveis de ambiente:

  1. Defina IP_ADDRESS como o endereço IP da instância do Compute Engine com o novo certificado SSL.

    Observe que os dois exemplos presumem que o servidor ainda não tem um nome de domínio totalmente qualificado (FQDN, na sigla em inglês) e, portanto, a suposição implícita é que ${IP_ADDRESS} foi usado como FQDN ao gerar o certificado autoassinado. Quando o servidor receber um FQDN, use-o para gerar o certificado e, em seguida, nos dois exemplos abaixo, substitua ${IP_ADDRESS} pelo FQDN.

  2. Defina ENDPOINTS_KEY como uma chave de API válida.

Com a porta SSL ativada, você pode usar HTTPS para enviar solicitações ao Extensible Service Proxy. Se seu certificado for autoassinado, use -k para ativar a opção não segura em curl:

curl -k -d '{"message":"hello world"}' -H "content-type:application/json" https://${IP_ADDRESS}:443/echo?key=${ENDPOINTS_KEY}
    

Ou gere o certificado no formato pem e use a opção --cacert para usar o certificado autoassinado em curl:

openssl x509 -in nginx.crt -out nginx.pem -outform PEM
    curl --cacert "./nginx.pem" -d '{"message":"hello world"}' -H "content-type:application/json" https://${IP_ADDRESS}:443/echo?key=${ENDPOINTS_KEY}
    

Como ativar o SSL usando certificados SSL gerenciados pelo Google

A compatibilidade do GKE com certificados SSL gerenciados pelo Google está na versão Beta. Siga as instruções em Como usar certificados SSL gerenciados pelo Google para configurar o SSL.

Se não quiser depender dos serviços Beta, integre o ESP diretamente a uma autoridade de certificação na implantação do GKE. Você pode usar:

Para mais informações, veja o tutorial Vamos criptografar no GKE ("Let's Encrypt on GKE", em inglês) no GitHub.