Alibaba Cloud Service Mesh:Integre o Keycloak ao ASM para single sign-on

Pré-requisitos

• Instância do ASM criada. Para mais informações, consulte Criar uma instância do ASM.

• Cluster gerenciado ACK criado. Para mais informações, consulte Criar um cluster gerenciado ACK.

• Cluster adicionado à instância do ASM.

• Injeção automática de sidecar ativada para o namespace default. Para mais informações, consulte Ativar injeção automática de sidecar.

Conceitos

Procedimento

Etapa 1: Implantar a aplicação de demonstração e o Keycloak

1. Use o manifesto YAML abaixo para implantar a aplicação httpbin no namespace default do cluster gerenciado ACK. Execute o comando kubectl apply -n default -f xxx.yaml.

   Visualize YAML

   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: httpbin
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: httpbin
     labels:
       app: httpbin
       service: httpbin
   spec:
     ports:
     - name: http
       port: 8000
       targetPort: 80
     selector:
       app: httpbin
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: httpbin
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: httpbin
         version: v1
     template:
       metadata:
         labels:
           app: httpbin
           version: v1
       spec:
         serviceAccountName: httpbin
         containers:
         - image: docker.io/kennethreitz/httpbin
           imagePullPolicy: IfNotPresent
           name: httpbin
           ports:
           - containerPort: 80

2. Use o manifesto YAML abaixo para implantar a aplicação Keycloak no namespace default do cluster gerenciado ACK. Execute o comando kubectl apply -n default -f xxx.yaml.

   Visualize YAML

   apiVersion: v1
   kind: Service
   metadata:
     name: keycloak
     labels:
       app: keycloak
   spec:
     ports:
     - name: http
       port: 8080
       targetPort: 8080
     selector:
       app: keycloak
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: keycloak
     labels:
       app: keycloak
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: keycloak
     template:
       metadata:
         labels:
           app: keycloak
       spec:
         containers:
         - name: keycloak
           image: quay.io/keycloak/keycloak:latest
           args: ["start-dev"]
           env:
           - name: KEYCLOAK_ADMIN
             value: "admin"
           - name: KEYCLOAK_ADMIN_PASSWORD
             value: "admin"
           - name: KC_PROXY
             value: "edge"
           ports:
           - name: http
             containerPort: 8080
           readinessProbe:
             httpGet:
               path: /realms/master
               port: 8080

Etapa 2: Expor a aplicação e o Keycloak via gateway

Neste exemplo, você acessa a aplicação de demonstração via HTTPS (porta 443) e o console do Keycloak via HTTP (porta 80).

1. Crie um certificado para o serviço HTTPS com o nome myexample-credential. Para mais informações, consulte Habilitar serviços HTTPS seguros usando um ASM Ingress Gateway.

2. Use o YAML abaixo para criar um Gateway e um VirtualService no cluster ASM e expor o Keycloak à rede pública.

   1. No console do ASM, configure o Gateway para a instância correspondente. Para mais informações, consulte Gerenciar regras de gateway.

      Visualize YAML

      apiVersion: networking.istio.io/v1beta1
      kind: Gateway
      metadata:
        name: ingressgateway
        namespace: istio-system
      spec:
        selector:
          app: istio-ingressgateway // Make sure that this selector matches the existing gateway.
        servers:
          - hosts:
              - '*'
            port:
              name: http-httpbin // Use HTTPS (port 443) to access the sample application.
              number: 443
              protocol: HTTPS
            tls:
              credentialName: myexample-credential
              mode: SIMPLE
          - hosts:
              - '*'
            port:
              name: keycloak // Use HTTP (port 80) to access the Keycloak console.
              number: 80
              protocol: HTTP
                                      

   2. Aplique o VirtualService abaixo na instância do ASM. Para mais informações, consulte Gerenciar virtual services.

      Visualize YAML

      apiVersion: networking.istio.io/v1beta1
      kind: VirtualService
      metadata:
        name: ingressgateway-vs
        namespace: istio-system
      spec:
        gateways:
          - ingressgateway
        hosts:
          - '*'
        http:
          - match:
              - port: 80
            name: keycloak
            route:
              - destination:
                  host: keycloak.default.svc.cluster.local
                  port:
                    number: 8080
          - name: httpbin
            route:
              - destination:
                  host: httpbin.default.svc.cluster.local
                  port:
                    number: 8000

3. No navegador, acesse http://${ASM_INGRESS_GATEWAY_ADDRESS} para abrir a aplicação Keycloak.

4. Clique em Administration Console e faça login com as credenciais de administrador definidas durante a implantação do Keycloak.

Etapa 3: Configurar o Keycloak

1. No painel de navegação à esquerda do Keycloak, selecione Master na lista suspensa e clique em Create Realm.

2. Na página de configuração do novo realm, crie um cliente. Na aba General Settings, defina Client type como OpenID Connect e Client ID como oauth2proxy. Na aba Capability config, ative Client authentication, desative Authorization e, em Authentication flow, marque apenas as caixas Standard flow e Direct access grants.

3. Crie um usuário no realm. Defina Username como asm-test e ative Email verified. Em seguida, clique em Save.

4. Na página User details, clique na aba Credentials.

5. Defina uma senha para o usuário. Mude Temporary para Off e clique em Save.

6. Crie uma função de realm. Defina Role name como test-role e clique em Save.

7. Na página User details, selecione a aba Role mapping.

8. Na página Role mapping, clique em Assign role. Atribua a função test-role ao usuário.

9. Crie um client scope. Defina Name como test_scope e Protocol como OpenID Connect. Ative Display on consent screen e Include in token scope. Depois, clique em Save.

10. Na página Client Scope, clique na aba Mappers e adicione um mapper. Defina Mapper type como Audience e Name como test-mapper. Em Included Client Audience, selecione oauth2proxy e ative Add to access token. Por fim, clique em Save.

11. Clique na aba Scope, marque a caixa ao lado da função test-role e clique em Assign.

12. Na página de configurações do cliente, clique na aba Client scopes e adicione o client scope test_scope como escopo padrão.

13. Adicione as Valid redirect URIs para o oauth2-proxy do cluster. Na aba Settings, na seção Access settings, insira https://${ASM ingress gateway address}/oauth2/callback no campo Valid redirect URIs e clique em Save.

Etapa 4: Habilitar autorização personalizada e SSO OIDC

1. Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.

2. Na página Mesh Management, clique no nome da instância do ASM. No painel de navegação à esquerda, escolha Mesh Security Center > Custom Authorization Service.

3. Na página External Authorization Service, clique em Register External Authorization Service e selecione OIDC Authz and Authn Service. Configure os parâmetros do Serviço de Autenticação e Autorização de Identidade OIDC e clique em Create.

   No painel Associate Custom Authorization Service, selecione OIDC Identity Authentication and Authorization Service como tipo e configure os parâmetros.

   Insira as informações do cliente OIDC criado no Keycloak. Você pode usar o ASM ingress gateway como redirect URI para login. Para mais detalhes sobre o cookie secret, consulte Generating a Cookie Secret.

   • IdP OIDC Issuer URL: http://${ASM_INGRESS_GATEWAY_ADDRESS}/realms/${REALM_NAME_IN_KEYCLOAK}.

   • ClientID e Client Secret: Use os valores anotados na etapa anterior.

   • Scopes: OpenID é um escopo obrigatório. Você pode especificar outros scopes conforme necessário.

4. Crie um VirtualService com o YAML abaixo.

   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: oauth2-vs
     namespace: istio-system
   spec:
     gateways:
       - ingressgateway
     hosts:
       - '*'
     http:
       - match:
           - uri:
               prefix: /oauth2
         name: oauth2
         route:
           - destination:
               host: asm-oauth2proxy-httpextauth-oidc.istio-system.svc.cluster.local
               port:
                 number: 4180

   Nota

   • Substitua o valor do campo host na seção route pelo nome do serviço oauth2-proxy no namespace istio-system do seu cluster ACK.

   • Para evitar conflitos de VirtualService, não configure outros VirtualServices com caminhos que tenham o prefixo /oauth2.

Etapa 5: Criar uma política de autorização

1. Na página Mesh Management, clique no nome da instância do ASM. No painel de navegação à esquerda, escolha Mesh Security Center > AuthorizationPolicy.

2. Na página AuthorizationPolicy, clique em Create from YAML.

3. Na página Create, selecione um Namespaces e um Scenario Template, configure o manifesto YAML abaixo e clique em Create.

   apiVersion: security.istio.io/v1beta1
   kind: AuthorizationPolicy
   metadata:
     name: oidc
     namespace: istio-system
   spec:
     action: CUSTOM
     provider:
       name: httpextauth-oidc
     rules:
       - to:
           - operation:
               notPorts:
                 - '80'
     selector:
       matchLabels:
         istio: ingressgateway

   Nota

   • Esta AuthorizationPolicy determina que todas as solicitações para portas diferentes da porta 80 exigem autorização.

   • Em provider.name, informe o nome do serviço de autorização personalizada associado. Você encontra esse nome na lista da página Custom Authorization Service.

Etapa 6: Verificar a integração

1. No navegador, acesse http://${ASM_INGRESS_GATEWAY_ADDRESS}:80.

   Resultado esperado: A página de login do OAuth2 Proxy é exibida com o botão Sign in with OpenID Connect, indicando que o single sign-on está ativo.

2. Clique em Sign in with OpenID Connect. Na página de login do Keycloak, insira as credenciais do usuário de teste criado na Etapa 3 e clique em Log In.

   Resultado esperado: Após o login, a página httpbin.org aparece, mostrando categorias de API como HTTP Methods, Auth, Status codes e Request Inspection.

3. Clique em Request inspection e selecione /headers > try it out > Execute.

   Resultado esperado: Na seção Server response, o corpo da resposta contém as informações do cabeçalho da solicitação, incluindo o campo Authorization: Bearer {JWT}. Isso confirma que a solicitação carrega o token JWT emitido pelo Keycloak.

4. Decodifique o token JWT da etapa anterior (a string após Bearer) usando um depurador de JWT. Para mais informações sobre depuradores de JWT, consulte JWT debugger.

   Resultado esperado: Após a decodificação bem-sucedida, o token revela que o algoritmo no HEADER é RS256 e o PAYLOAD contém claims como realm_access (informações de função), preferred_username (nome de usuário) e client_id (oauth2proxy). Isso confirma que o ASM verificou o JWT e que ele inclui as informações do usuário armazenadas no Keycloak.