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.

Exporte o nome de domínio do Centro de gerenciamento como uma variável, por exemplo:
```
export ANTHOS_MANAGEMENT_CENTER=anthos.example.com
```
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

Faça o download da imagem do Keycloak no dockerhub:
```
actl images save \
  --output keycloak-image \
  jboss/keycloak:12.0.2
```
Observação: keycloak:12.0.2 é a única versão que testamos para esta demonstração como um provedor OIDC para o Anthos em execução no modo desconectado.

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.

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

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}')

Adicione um "registro A" à configuração do domínio DNS e defina-o como ${KEYCLOAK_SVC_IP}:
```
export KEYCLOAK_SVC=keycloak.example.com
```

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"

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

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

Passe o cursor sobre a opção Mestre no canto superior esquerdo e clique em Adicionar realm.
Digite anthos como o nome do novo realm e clique em Criar.
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

Na barra de navegação à esquerda, clique em Usuários, depois em Adicionar usuário.
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
Na guia Credenciais, preencha os campos Senha e Confirmação da senha. Clique em Definir senha e valide quando solicitado.

Criar um cliente

Na barra de navegação à esquerda, clique em Clientes e em Criar.
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
Acesse a página de gerenciamento do cliente recém-criado.
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.
Na guia Credenciais da página de gerenciamento de clientes, selecione ID do cliente e secret como autenticador do cliente.
Anote o secret em algum lugar.
(Recomendado) Configurar a assinatura de grupo no Keycloak
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.

Execute este comando:

export ISSUER_URL=https://${KEYCLOAK_SVC}/auth/realms/anthos
echo "Issuer URL: ${ISSUER_URL}"

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}"

Abordagem recomendada usando o console do Centro de gerenciamento

No console do Centro de gerenciamento, abra o menu Identidade e acesso.
Na guia Identidade, clique em Configurar o Anthos Identity Service (OIDC)
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.
Observação: o prefixo do nome de usuário e o prefixo do grupo podem ser definidos como valores diferentes. Lembre-se de adicionar esses prefixos ao vincular contas a papéis.
Clique em Aplicar perfis aos clusters e clique na guia Cluster de administradores.
Para Perfis, escolha o perfil "keycloak" que você acabou de criar.
Em Nome de domínio, insira ANTHOS_MANAGEMENT_CENTER.
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.
Clique em Enviar e aguarde um minuto para que os vários componentes do sistema sejam reconfigurados.
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

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

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

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

Substitua YOUR_CLIENT_SECRET pela chave secreta do cliente recebida na guia Credenciais do Keycloak.

Execute o seguinte comando para configurar o OIDC:

kubectl patch ClientConfig default -n kube-public --type=merge \
    --patch "$(cat clientconfig-patch.yaml)"

Aguarde um minuto para que os vários componentes do sistema sejam reconfigurados.
Siga as instruções em Configurar papéis de autorização para configurar a conta de administrador da plataforma inicial.
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.

Faça login no console do Google Cloud e selecione um projeto válido.
Acesse a seção "API e serviços > Tela de consentimento do OAuth".
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.
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
Copie o ID e a chave secreta do cliente para a configuração do AdminUI.
Defina o URL do provedor OIDC como https://accounts.google.com.
Defina Username Claim como email e Scopes como openid email.
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.
Adicione a lista inicial de e-mails dos usuários (separados por vírgulas) para receber permissões de administrador da plataforma.
Clique em Save.

SSO do Google

A seguir

Configure a identidade e a segurança nos clusters de usuário.