Demonstração: autenticar com o Keycloak ou o SSO do Google

Esta página é destinada a administradores da plataforma.

É possível fazer a autenticação com o Keycloak ou o Logon único (SSO) do Google apenas para fins de demonstração ou teste.

Autenticar com o Keycloak

O Keycloak é um produto de gerenciamento de identidade e acesso de software de código aberto. É possível configurá-lo como um provedor OIDC para uma demonstração rápida.

Antes de começar

Para instalar e ativar o Keycloak, você precisa ter um cluster do Kubernetes que tenha um endereço de entrada que possa ser acessado na implantação do Anthos em execução no modo desconectado. Um cluster de admin do Anthos em execução no modo desconectado é usado como exemplo nesta página.

Você também precisa ter criado um nome de domínio personalizado para o Centro de gerenciamento do Anthos em execução no modo desconectado. Consulte Configurar o nome de domínio para acessar o Centro de gerenciamento.

  1. Exporte o nome de domínio do Centro de gerenciamento como uma variável, por exemplo:

    export ANTHOS_MANAGEMENT_CENTER=anthos.example.com
    
  2. Exporte um registro privado como uma variável, por exemplo:

    export PRIVATE_REGISTRY=10.200.0.2/library
    

Faça o download da imagem do Keycloak e enviá-la para o registro particular

  1. Faça o download da imagem do Keycloak no dockerhub:

    actl images save \
      --output keycloak-image \
      jboss/keycloak:12.0.2
    
  2. Envie a imagem do Keycloak para o registro particular:

    actl images push \
      --images keycloak-image \
      --private-registry=${PRIVATE_REGISTRY}
    

Implantar o Keycloak

Atualize a configuração do DNS e gere um certificado para implantar o Keycloak.

  1. Crie o serviço Keycloak para expor o IP para Keycloak:

    kubectl create -f - <<EOF
    apiVersion: v1
    kind: Namespace
    metadata:
      name: keycloak
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: keycloak-svc
      namespace: keycloak
      labels:
        app: keycloak
    spec:
      ports:
      - name: http
        port: 80
        targetPort: 8080
      - name: https
        port: 443
        targetPort: 8443
      selector:
        app: keycloak
      type: LoadBalancer
    EOF
    
  2. Depois que um IP é alocado pelo LoadBalancer, exporte-o para uma variável. Por exemplo:

    export KEYCLOAK_SVC_IP=$(kubectl get services -n keycloak \
        -o jsonpath='{.items[0].status.loadBalancer.ingress[0].ip}')
    
  3. Adicione um "registro A" à configuração do domínio DNS e defina-o como ${KEYCLOAK_SVC_IP}:

    export KEYCLOAK_SVC=keycloak.example.com
    
  4. Gere um certificado autoassinado para que o Keycloak use o TLS.

    openssl req -new -newkey rsa:4096 -x509 -sha256 -days 365 -nodes -subj \
        "/CN=${KEYCLOAK_SVC}" \
        -addext "subjectAltName = DNS:localhost,DNS:${KEYCLOAK_SVC},IP:${KEYCLOAK_SVC_IP}" \
        -out "tls.crt" -keyout "tls.key"
    
  5. Faça upload do certificado e da chave privada no cluster:

    kubectl create secret tls tls-config -n keycloak --cert=tls.crt \
        --key=tls.key
    
  6. Execute o seguinte comando para implantar o Keycloak:

    kubectl create -f - <<EOF
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: keycloak
      namespace: keycloak
      labels:
        app: keycloak
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: keycloak
      template:
        metadata:
          labels:
            app: keycloak
        spec:
          volumes:
          - name: tls-config-volume
            secret:
              secretName: tls-config
              items:
              - key: tls.crt
                path: tls.crt
              - key: tls.key
                path: tls.key
          containers:
          - name: keycloak
            # Set the image as original path but the actual image will be pulled from the registry mirror,
            # which was configured by 'actl push' command.
            image: jboss/keycloak:12.0.2
            # Keycloak uses certificates stored in /etc/x509/https to set up TLS.
            # https://github.com/keycloak/keycloak-containers/blob/master/server/README.md#setting-up-tlsssl
            volumeMounts:
            - name: tls-config-volume
              mountPath: "/etc/x509/https"
            env:
            - name: KEYCLOAK_USER
              value: "admin"
            - name: KEYCLOAK_PASSWORD
              value: "admin"
            - name: PROXY_ADDRESS_FORWARDING
              value: "true"
            ports:
            - name: http
              containerPort: 8080
            - name: https
              containerPort: 8443
            readinessProbe:
              httpGet:
                path: /auth/realms/master
                port: 8080
    EOF
    

Configurar o usuário e o cliente do Keycloak

Abra o console do Keycloak na estação de trabalho do administrador e faça login com KEYCLOAK_USER e KEYCLOAK_PASSWORD no arquivo keycloak.yaml. Por padrão, esses valores são KEYCLOAK_USER=admin e KEYCLOAK_PASSWORD=admin. Se necessário, aceite o certificado autoassinado no navegador. Se o Chrome exibir um aviso sobre um certificado não confiável, insira thisisunsafe na caixa de diálogo.

echo "Keycloak console: https://${KEYCLOAK_SVC}"

Criar um realm

  1. Passe o cursor sobre a opção Mestre no canto superior esquerdo e clique em Adicionar realm.
  2. Digite anthos como o nome do novo realm e clique em Criar.
  3. Em Configurações do realm > Tokens, altere a duração do token de acesso para 1 Hour para evitar que ele expire muito cedo e, em seguida, clique em Salvar.

Criar um usuário

  1. Na barra de navegação à esquerda, clique em Usuários, depois em Adicionar usuário.
  2. Defina as configurações a seguir para o usuário e clique em Salvar.
    1. Nome de usuário: anthos-platform-admin
    2. E-mail: anthos-platform-admin@example.com
    3. Usuário ativado: ON
    4. E-mail verificado: ON
  3. Na guia Credenciais, preencha os campos Senha e Confirmação da senha. Clique em Definir senha e valide quando solicitado.

Criar um cliente

  1. Na barra de navegação à esquerda, clique em Clientes e em Criar.
  2. Defina as configurações a seguir para o cliente e clique em Salvar. ANTHOS_MANAGEMENT_CENTER é o nome de domínio personalizado que você usa para a central de gerenciamento.
    1. ID do cliente: anthos
    2. Protocolo do cliente: openid-connect
    3. URL raiz: https://ANTHOS_MANAGEMENT_CENTER
  3. Acesse a página de gerenciamento do cliente recém-criado.
  4. Na guia Configurações da página de gerenciamento de clientes, execute as seguintes etapas:
    1. Defina o Tipo de acesso como confidential.
    2. Adicione os seguintes URIs aos URIs de redirecionamento válidos.
      • http://localhost:9879/callback
      • https://ANTHOS_MANAGEMENT_CENTER/_gcp_anthos_oidc_callback
    3. Clique em Save.
  5. Na guia Credenciais da página de gerenciamento de clientes, selecione ID do cliente e secret como autenticador do cliente.
  6. Anote o secret em algum lugar.
    1. Na barra de navegação à esquerda, clique em Grupos e em Nova.
    2. Digite o nome do seu grupo: anthos-platform-admin-group.
    3. Volte à guia Usuário à esquerda e clique em Visualizar todos os usuários.
    4. Clique no usuário que você acabou de criar (anthos-platform-admin) e clique na guia Grupos.
    5. Em Grupos disponíveis, selecione o grupo que você criou, anthos-platform-admin-group, e clique em Participar.
    6. Volte para a página de gerenciamento de clientes anthos.
    7. Clique na guia Mapeadores e depois em Criar:
      1. Insira o nome deste mapeador: anthos-platform-admin-group-mapper.
      2. Na lista suspensa Tipo de mapeador, selecione Assinatura do grupo.
      3. Token Claim Name é o valor do atributo mostrado no token de autenticação. O valor padrão no Anthos em execução no modo desconectado é "groups". É possível usar groups neste campo. Lembre-se de que você precisará modificar o campo GroupsClaim de configurações do OIDC com esse valor se o nome Token Claim Name não for groups.
      4. Verifique se a opção Caminho do grupo completo está desativada.
      5. Verifique se as opções Adicionar ao token de ID, Adicionar ao token de acesso e Adicionar ao informações do usuário estão ativadas.
      6. Clique em Save.

Ativar a autenticação do OIDC

Consiga o URL do provedor OIDC para usar nas etapas a seguir.

  1. Execute este comando:

    export ISSUER_URL=https://${KEYCLOAK_SVC}/auth/realms/anthos
    echo "Issuer URL: ${ISSUER_URL}"
    
  2. Usando o tls.crt de antes, gere o certificado codificado em Base64.

    export BASE64_CERT=$(openssl base64 -A -in tls.crt)
    echo "Use the following string as the base64-encoded certificate for the OIDC provider: ${BASE64_CERT}"
    
  1. No console do Centro de gerenciamento, abra o menu Identidade e acesso.
  2. Na guia Identidade, clique em Configurar o Anthos Identity Service (OIDC)
  3. Crie o perfil do Keycloak preenchendo os campos a seguir e clique em Enviar:

    1. Nome do perfil: keycloak
    2. URL do provedor de OIDC: o URL do emissor da seção Ativar autenticação do OIDC.
    3. ID do cliente de OIDC: anthos
    4. Chave secreta do cliente de OIDC: a chave secreta do cliente da seção Criar um cliente.
    5. Reivindicação de nome de usuário: email
    6. Prefixo do nome de usuário: keycloak-
    7. Reivindicação de grupos: a reivindicação de grupos da seção Configurar associação a grupos. Se você deixar esse campo em branco, o valor será groups.
    8. Prefixo do grupo: keycloak-
    9. Escopos: email openid
    10. Parâmetros extra: access_type=offline
    11. Dados da autoridade de certificação: use o certificado codificado em base64 da seção Ativar autenticação OIDC.
  4. Clique em Aplicar perfis aos clusters e clique na guia Cluster de administradores.

  5. Para Perfis, escolha o perfil "keycloak" que você acabou de criar.

  6. Em Nome de domínio, insira ANTHOS_MANAGEMENT_CENTER.

  7. Em Administrador da plataforma inicial, sempre adicione o prefixo do usuário antes do seu nome de usuário. Por exemplo, se você estiver adicionando anthos-platform-admin@example.com, digite keycloak-anthos-platform-admin@example.com.

  8. Clique em Enviar e aguarde um minuto para que os vários componentes do sistema sejam reconfigurados.

  9. Em uma janela anônima, acesse https://ANTHOS_MANAGEMENT_CENTER. Você será redirecionado para uma página de login do Keycloak e poderá fazer login como anthos-platform-admin (após definir uma senha permanente).

Segunda abordagem aplicando um arquivo yaml

  1. Defina o provedor de IDP para o domínio. Se o DomainConfig já estiver criado para o domínio, corrija o objeto para definir o nome do método de autenticação a ser usado para o domínio com este comando:

    kubectl patch domainconfig anthos.example.com --type=json -p='[{"op": "replace", "path":
    "/spec/authMethodName", "value":"keycloak"}]'
    

    Se DomainConfig não for criado para o domínio, crie-o com este comando:

    kubectl create -f - <<EOF
    apiVersion: managementcenter.anthos.cloud.google.com/v1
    kind: DomainConfig
    metadata:
      name: anthos.example.com
    spec:
      authMethodName: keycloak
    EOF
    
  2. Crie o clientconfig-patch.yaml com o seguinte conteúdo:

    # Use this to set the OIDC configuration of Keycloak:
    # kubectl patch ClientConfig default -n kube-public --type=merge --patch $(cat clientconfig-patch.yaml)
    spec:
      authentication:
      # The name of the OIDC configuration to create.
      - name: keycloak
        oidc:
          # ID for the client application that makes authentication requests to the OpenID provider.
          clientID: anthos
          # ID for the client application that makes authentication requests to the OpenID provider.
          clientSecret: YOUR_CLIENT_SECRET
          # The URI to redirect users going through the OAuth flow using cloud console.
          # This is not supported by Anthos running in disconnected mode.
          cloudConsoleRedirectURI: http://cloud.console.not.enabled
          # Additional key-value parameters (comma-separated) to send to the OpenID provider.
          extraParams: access_type=offline
          # URL where authorization requests are sent to your OpenID.
          issuerURI: YOUR_ISSUER_URI
          # The redirect URL that kubectl uses for authorization.
          kubectlRedirectURI: http://localhost:9879/callback
          # Additional scopes to send to the OpenID provider.
          scopes: openid email
          # JWT claim to use as the username. You can choose other claims, such as email or name,
          # depending on the OpenID provider. However, claims other than email are prefixed
          # with the issuer URL to prevent naming clashes.
          userClaim: email
          # A base64-encoded PEM-encoded certificate for the OIDC provider. To create the string,
          # encode the certificate, including headers, into base64. Include the resulting string
          # in certificateAuthorityData as a single line.
          certificateAuthorityData: YOUR_CERTIFICATE
    
  3. Edite o clientconfig-patch.yaml com as configurações do Keycloak.

    sed -i "s|YOUR_ISSUER_URI|${ISSUER_URL}|g" clientconfig-patch.yaml
    sed -i "s|YOUR_CERTIFICATE|${BASE64_CERT}|g" clientconfig-patch.yaml
    
  4. Substitua YOUR_CLIENT_SECRET pela chave secreta do cliente recebida na guia Credenciais do Keycloak.

  5. Execute o seguinte comando para configurar o OIDC:

    kubectl patch ClientConfig default -n kube-public --type=merge \
        --patch "$(cat clientconfig-patch.yaml)"
    
  6. Aguarde um minuto para que os vários componentes do sistema sejam reconfigurados.

  7. Siga as instruções em Configurar papéis de autorização para configurar a conta de administrador da plataforma inicial.

  8. Em uma janela anônima, acesse https://ANTHOS_MANAGEMENT_CENTER. Você será redirecionado para uma página de login do Keycloak e poderá fazer login como anthos-platform-admin (após definir uma senha permanente).

Excluir keycloak

Depois de usar a demonstração do Keycloak, exclua a instalação do Keycloak.

kubectl delete ns keycloak

Autenticar com o SSO do Google

O SSO do Google não está disponível no modo particular do Anthos. Se você quiser usar o SSO do Google, o cluster e os navegadores precisam ser capazes de entrar em contato com os servidores de SSO do Google. Os servidores de SSO do Google não precisam entrar em contato com os clusters do usuário.

  1. Faça login no console do Google Cloud e selecione um projeto válido.
  2. Acesse a seção "API e serviços > Tela de consentimento do OAuth".
  3. Crie uma nova tela de consentimento do OAuth. Essas informações são exibidas para os usuários.
    1. Defina a Página inicial do aplicativo como o URL Admin.
  4. Na seção APIs e serviços > Credenciais:
    1. Clique em Criar credenciais.
    2. Crie um novo ID do cliente OAuth.
    3. Defina o tipo de aplicativo como Aplicativo da Web.
    4. Escolha um nome relevante.
    5. Para as origens do JavaScript, defina https://anthos.example.com, supondo que https://anthos.example.com seja o nome do domínio do centro de gerenciamento.
    6. Para os URIs de redirecionamento autorizados, configure:
      • https://anthos.example.com/_gcp_anthos_oidc_callback
      • http://localhost:9879/callback
  5. Copie o ID e a chave secreta do cliente para a configuração do AdminUI.
  6. Defina o URL do provedor OIDC como https://accounts.google.com.
  7. Defina Username Claim como email e Scopes como openid email.
  8. Defina os parâmetros extras como prompt=consent,access_type=offline. Caso contrário, não será possível fazer login com o servidor da API Kubernetes.
  9. Adicione a lista inicial de e-mails dos usuários (separados por vírgulas) para receber permissões de administrador da plataforma.
  10. Clique em Save.

SSO do Google

A seguir