Alibaba Cloud Service Mesh:Implementar autorização personalizada usando o protocolo gRPC

Como funciona

Ao ativar a autorização externa no ASM, o fluxo da solicitação ocorre da seguinte maneira:

1. Um cliente envia uma solicitação para um serviço de destino (por exemplo, httpbin).

2. O proxy sidecar intercepta a solicitação e envia uma verificação de autorização para o seu serviço gRPC externo.

3. O serviço externo avalia a solicitação e retorna uma decisão de permissão ou negação.

4. Se permitida, a solicitação segue para o serviço de destino. Se negada, o proxy retorna um erro imediatamente ao cliente.

As verificações de autorização são acionadas apenas para solicitações que correspondem às regras definidas na sua política de autorização. Solicitações para caminhos ou serviços não cobertos pela política passam diretamente, sem verificação externa.

Pré-requisitos

Antes de começar, certifique-se de ter:

• Um cluster do Container Service for Kubernetes (ACK) adicionado à sua instância do ASM. Para mais informações, consulte Adicionar um cluster a uma instância do ASM.

• kubectl configurado para se conectar ao seu cluster ACK. Para mais informações, consulte Obter o arquivo kubeconfig de um cluster e usar kubectl para se conectar ao cluster.

Etapa 1: Implantar o serviço de autorização externa

Implante um serviço de autorização baseado em gRPC no seu cluster ACK. Este serviço implementa a API ext_authz do Envoy e gerencia as verificações de autorização para solicitações recebidas.

O serviço de exemplo usado aqui permite solicitações que contêm o cabeçalho x-ext-authz: allow e nega todo o restante. Use este exemplo como está ou personalize-o conforme sua própria lógica. O código-fonte está disponível no GitHub.

1. Crie um arquivo chamado ext-authz.yaml com o seguinte conteúdo:

   ext-authz.yaml

   # Copyright Istio Authors
   #
   #   Licensed under the Apache License, Version 2.0 (the "License");
   #   you may not use this file except in compliance with the License.
   #   You may obtain a copy of the License at
   #
   #       http://www.apache.org/licenses/LICENSE-2.0
   #
   #   Unless required by applicable law or agreed to in writing, software
   #   distributed under the License is distributed on an "AS IS" BASIS,
   #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   #   See the License for the specific language governing permissions and
   #   limitations under the License.
   
   # Example configurations for deploying ext-authz server separately in the mesh.
   
   apiVersion: v1
   kind: Service
   metadata:
     name: ext-authz
     labels:
       app: ext-authz
   spec:
     ports:
     - name: http
       port: 8000
       targetPort: 8000
     - name: grpc
       port: 9000
       targetPort: 9000
     selector:
       app: ext-authz
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: ext-authz
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: ext-authz
     template:
       metadata:
         labels:
           app: ext-authz
       spec:
         containers:
         - image: istio/ext-authz:0.6
           imagePullPolicy: IfNotPresent
           name: ext-authz
           ports:
           - containerPort: 8000
           - containerPort: 9000

   O Service expõe duas portas: HTTP na porta 8000 e gRPC na porta 9000. Este tutorial utiliza a porta gRPC (9000).

2. Implante o serviço:

   kubectl apply -f ext-authz.yaml

   Saída esperada:

   service/ext-authz created
   deployment.apps/ext-authz created

3. Verifique se o serviço está em execução:

   kubectl logs "$(kubectl get pod -l app=ext-authz -n default -o jsonpath={.items..metadata.name})" -n default -c ext-authz

   Saída esperada:

   2023/12/20 08:15:39 Starting gRPC server at [::]:9000
   2023/12/20 08:15:39 Starting HTTP server at [::]:8000

   Os servidores gRPC e HTTP devem estar em execução. Se nenhuma saída aparecer, aguarde alguns segundos para o pod iniciar e tente novamente.

4. Confirme a porta gRPC do serviço ext-authz:

   1. Faça login no console do ACK. No painel de navegação à esquerda, clique em Clusters.

   2. Na página Clusters, localize o cluster e clique no nome dele. No painel à esquerda, escolha Network > Services.

   3. Na página Services, clique em ext-authz.

   A seção Endpoint exibe a porta gRPC. Neste exemplo, a porta é 9000.

Etapa 2: Implantar aplicativos de exemplo

Implante os aplicativos httpbin e sleep. O httpbin atua como o serviço de destino que recebe solicitações, enquanto o sleep funciona como o cliente que as envia.

1. Crie um arquivo chamado httpbin.yaml com o seguinte conteúdo:

   httpbin.yaml

   # Copyright Istio Authors
   #
   #   Licensed under the Apache License, Version 2.0 (the "License");
   #   you may not use this file except in compliance with the License.
   #   You may obtain a copy of the License at
   #
   #       http://www.apache.org/licenses/LICENSE-2.0
   #
   #   Unless required by applicable law or agreed to in writing, software
   #   distributed under the License is distributed on an "AS IS" BASIS,
   #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   #   See the License for the specific language governing permissions and
   #   limitations under the License.
   
   ##################################################################################################
   # httpbin service
   ##################################################################################################
   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. Implante o httpbin:

   kubectl apply -f httpbin.yaml

3. Crie um arquivo chamado sleep.yaml com o seguinte conteúdo:

   sleep.yaml

   # Copyright Istio Authors
   #
   #   Licensed under the Apache License, Version 2.0 (the "License");
   #   you may not use this file except in compliance with the License.
   #   You may obtain a copy of the License at
   #
   #       http://www.apache.org/licenses/LICENSE-2.0
   #
   #   Unless required by applicable law or agreed to in writing, software
   #   distributed under the License is distributed on an "AS IS" BASIS,
   #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   #   See the License for the specific language governing permissions and
   #   limitations under the License.
   
   ##################################################################################################
   # Sleep service
   ##################################################################################################
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: sleep
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: sleep
     labels:
       app: sleep
       service: sleep
   spec:
     ports:
     - port: 80
       name: http
     selector:
       app: sleep
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: sleep
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: sleep
     template:
       metadata:
         labels:
           app: sleep
       spec:
         terminationGracePeriodSeconds: 0
         serviceAccountName: sleep
         containers:
         - name: sleep
           image: curlimages/curl
           command: ["/bin/sleep", "3650d"]
           imagePullPolicy: IfNotPresent
           volumeMounts:
           - mountPath: /etc/sleep/tls
             name: secret-volume
         volumes:
         - name: secret-volume
           secret:
             secretName: sleep-secret
             optional: true

4. Implante o sleep:

   kubectl apply -f sleep.yaml

Etapa 3: Registrar o serviço de autorização externa no ASM

Registre o serviço ext-authz implantado na Etapa 1 como um provedor de autorização personalizado na sua instância do ASM. Isso informa ao plano de controle do mesh para onde rotear as verificações de autorização.

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 sua instância do ASM. No painel de navegação à esquerda, escolha Mesh Security Center > Custom Authorization Service. Clique em Define Custom Authorization Service.

3. Na página Register Custom Authorization Service, clique na aba Custom authorization service (HTTP or gRPC protocol) implemented based on envoy.ext_authz. Configure os seguintes parâmetros e clique em Create.

   Parâmetros obrigatórios

   Parâmetro	Descrição	Valor de exemplo
   Protocol	Protocolo utilizado pelo serviço de autorização.	GRPC
   Name	Nome para este registro de serviço de autorização.	test
   Service Address	Endpoint do serviço no formato <Nome do Serviço>.<Namespace>.svc.<Domínio do Cluster>.	ext-authz.default.svc.cluster.local
   Port(1 - 65535)	Porta gRPC do serviço de autorização.	9000
   Timeout(second)	Tempo máximo de espera por uma resposta de autorização. Se o serviço não responder dentro desse período, a solicitação será tratada como não autorizada (a menos que você ative a opção de ignorar abaixo).	10

   Parâmetros opcionais

   Parâmetro	Descrição
   Skip authentication while authorization service is unavailable	Quando ativado, as solicitações são permitidas se o serviço de autorização estiver inacessível. Quando desativado, as solicitações são negadas.
   Error code returned by asm proxy while Auth-Service is not available	Código de erro HTTP personalizado retornado aos chamadores quando o serviço de autorização está indisponível. Disponível apenas quando Skip authentication while authorization service is unavailable está desativado.
   Carry origin request body within auth request	Quando ativado, o corpo da solicitação original é encaminhado ao serviço de autorização. Defina um comprimento máximo de corpo. Se Allow send incomplete message to Auth-Service também estiver ativado, corpos que excederem o comprimento máximo serão truncados em vez de rejeitados.

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

Crie uma política de autorização para definir quais solicitações exigem uma verificação de autorização externa.

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 sua instância do ASM. No painel de navegação à esquerda, escolha Mesh Security Center > AuthorizationPolicy. Clique em Create.

3. Na página Create, configure os seguintes parâmetros e clique em Create.

   Parâmetro	Descrição	Valor de exemplo
   Name	Nome da política de autorização.	test1
   Policy Type	Tipo da política de autorização.	Custom Authorization Service
   Custom Authorization Service	Serviço de autorização externa a ser utilizado.	grpcextauth-test(GRPC)
   Namespace	Namespace onde a política se aplica. Definido na aba Workload Scope.	default
   Effective Scope	Indica se a política se aplica a um serviço específico ou a todo o namespace.	Service
   Workload	Carga de trabalho alvo desta política.	httpbin
   Request Matching Rules	Condições da solicitação que acionam uma verificação de autorização. Ative Paths na seção Add Request Target.	/headers

   Com essa configuração, apenas solicitações para o caminho /headers no serviço httpbin passam pela verificação de autorização externa. Solicitações para outros caminhos (como /ip) não são afetadas.

Etapa 5: Verificar o fluxo de autorização

Teste a configuração enviando solicitações do pod sleep para o serviço httpbin. Os três cenários a seguir confirmam que a autorização funciona corretamente.

kubectl exec "$(kubectl get pod -l app=sleep -n default -o jsonpath={.items..metadata.name})" -c sleep -n default -- curl "http://httpbin.default:8000/ip" -s -o /dev/null -w "%{http_code}\n"

200

kubectl exec "$(kubectl get pod -l app=sleep -n default -o jsonpath={.items..metadata.name})" -c sleep -n default -- curl "http://httpbin.default:8000/headers" -H "x-ext-authz: deny" -s

denied by ext_authz for not found header `x-ext-authz: allow` in the request

kubectl exec "$(kubectl get pod -l app=sleep -n default -o jsonpath={.items..metadata.name})" -c sleep -n default -- curl "http://httpbin.default:8000/headers" -H "x-ext-authz: allow" -s

{
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.default:8000",
    "User-Agent": "curl/8.5.0",
    "X-Envoy-Attempt-Count": "1",
    "X-Ext-Authz": "allow",
    "X-Ext-Authz-Check-Result": "allowed",
    "X-Forwarded-Client-Cert": "By=spiffe://cluster.local/ns/default/sa/httpbin;Hash=c3e5364e87add0f4f69e6b0d029f5961b404c8f209bf9004b3d21a82cf67****;Subject=\"\";URI=spiffe://cluster.local/ns/default/sa/sleep"
  }
}

Consulte também

• Desenvolver um serviço de autorização personalizado baseado em HTTP

• Desenvolver um serviço de autorização personalizado baseado em gRPC

• Implementar autorização personalizada com o protocolo HTTP

• Controlar o acesso de serviços do mesh a um site externo

• Controlar o acesso de serviços do mesh a um banco de dados externo

• Usar o recurso de auditoria de operações KubeAPI no ASM

• Configurar alertas de auditoria para operações de recursos do ASM