Configure access policies for workloads - Alibaba Cloud Service Mesh

Par défaut, les charges de travail au sein d'une instance Service Mesh (ASM) peuvent communiquer entre elles. Vous pouvez créer des politiques d'autorisation afin d'effectuer un contrôle d'accès et une gestion des autorisations sur les charges de travail dans un cluster. Dans ce cas, seules les requêtes répondant à des exigences spécifiques peuvent accéder aux charges de travail. Par exemple, vous pouvez contrôler l'accès aux charges de travail en spécifiant les chemins de requête, les méthodes de requête et les adresses IP des clients. Cette approche renforce la sécurité et protège les ressources de l'instance ASM.

Prérequis

Le cluster est ajouté à l'instance ASM.

Présentation de la fonctionnalité

Vous pouvez spécifier l'action CUSTOM, DENY ou ALLOW dans une politique d'autorisation. Les politiques d'autorisation possèdent différents niveaux de priorité lorsque vous en appliquez plusieurs à une seule charge de travail. Plus précisément, le système vérifie les requêtes en fonction des politiques d'autorisation CUSTOM, DENY, puis ALLOW, dans cet ordre. Si vous créez plusieurs politiques d'autorisation pour une charge de travail, les règles suivantes s'appliquent :

Si une requête correspond à la condition d'une politique d'autorisation CUSTOM qui rejette la requête, celle-ci est rejetée.
Si une requête correspond à la condition d'une politique d'autorisation DENY qui rejette la requête, celle-ci est rejetée.
Par défaut, si aucune politique d'autorisation ALLOW n'est configurée pour une charge de travail, la requête peut accéder à cette charge de travail.
Si une politique d'autorisation ALLOW est configurée pour une charge de travail et qu'une requête correspond à la condition de cette politique, la requête peut accéder à la charge de travail.
Si une requête ne satisfait pas toutes les conditions précédentes, elle est rejetée.

Cette rubrique propose les quatre exemples suivants pour vous aider à comprendre et configurer rapidement les politiques d'autorisation :

Exemple 1 : Contrôler l'accès à un chemin spécifique d'une charge de travail
Exemple 2 : Contrôler la méthode de requête et l'accès à un chemin spécifique d'une charge de travail
Exemple 3 : Contrôler l'accès à une charge de travail par adresses IP client
Exemple 4 : Contrôler l'accès aux services entre les namespaces

Scénario 1 : Contrôler l'accès à un chemin spécifique d'une charge de travail

Dans cet exemple, une politique d'autorisation est créée pour spécifier que les applications du namespace foo peuvent accéder au chemin /headers de l'application HTTPBin. L'application HTTPBin réside dans le namespace foo. Les requêtes vers d'autres chemins échouent. Les applications situées dans des namespaces autres que foo ne peuvent pas accéder à l'application HTTPBin.

Étape 1 : Activer l'injection automatique du proxy sidecar pour les namespaces default et foo

Créez les namespaces default et foo. Pour plus d'informations, consultez la rubrique Créer un namespace.
Activez l'injection automatique du proxy sidecar pour les namespaces default et foo. Pour plus d'informations, consultez la rubrique Activer l'injection automatique du proxy sidecar.

Étape 2 : Déployer les applications de test

Déployez l'application sleep dans les namespaces default et foo.

Créez un fichier sleep.yaml contenant le contenu suivant :

Show the sleep.yaml file

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

Exécutez la commande suivante pour déployer l'application sleep dans le namespace default :
```
kubectl apply -f sleep.yaml -n default
```
Exécutez la commande suivante pour déployer l'application sleep dans le namespace foo :
```
kubectl apply -f sleep.yaml -n foo
```

Déployez l'application HTTPBin dans le namespace foo.

Créez un fichier httpbin.yaml contenant le contenu suivant :

Show the httpbin.yaml file

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

Exécutez la commande suivante pour déployer l'application HTTPBin dans le namespace foo :
```
kubectl apply -f httpbin.yaml -n foo
```

Étape 3 : Créer une politique d'autorisation

Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.
Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez Mesh Security Center > AuthorizationPolicy. Sur la page qui s'affiche, cliquez sur Create.

Sur la page Create, configurez les paramètres et cliquez sur Create.

Paramètre	Description
Name	Nom de la politique d'autorisation.
Policy Type	Définissez la valeur sur ALLOW.
Namespaces	Dans l'onglet Workload Scope, définissez Namespaces sur foo.
Effective Scope	Sélectionnez Service.
Workload	Sélectionnez httpbin.
Request Matching Rules	Dans la section Add Request Source, activez le commutateur Namespaces et définissez la valeur sur `foo`. Cela permet à toutes les applications du namespace `foo` d'accéder à l'application `httpbin`. Dans la section Add Request Target, activez le commutateur Paths et définissez la valeur sur `/headers`. Cela permet aux applications d'accéder uniquement au chemin `/headers` de l'application `httpbin` dans le namespace `foo`.

Étape 4 : Vérifier si la politique d'autorisation contrôlant l'accès au chemin spécifique prend effet

Envoyez une requête en utilisant l'application sleep du namespace default pour accéder à l'application HTTPBin du namespace foo.
1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Pods.
3. En haut de la page Pods, définissez Namespaces sur default. Recherchez le pod sleep et cliquez sur Terminal > sleep dans la colonne Actions.
4. Exécutez la commande suivante dans la section Terminal du conteneur sleep pour accéder au chemin /headers de l'application HTTPBin :
```
curl httpbin.foo.svc.cluster.local:8000/headers
```
  Le code 403 est renvoyé, ce qui indique que la requête est rejetée.
5. Exécutez la commande suivante dans la section Terminal du conteneur sleep pour accéder au chemin /ip de l'application HTTPBin :
```
curl httpbin.foo.svc.cluster.local:8000/ip
```
  Le code 403 est renvoyé, ce qui indique que la requête est rejetée.
Envoyez une requête en utilisant l'application sleep du namespace foo pour accéder à l'application HTTPBin du namespace foo.
1. Dans le volet de navigation de gauche de la page de gestion du cluster, sélectionnez Workload > Pods.
2. En haut de la page Pods, définissez Namespaces sur foo. Recherchez le pod sleep et cliquez sur Terminal > sleep dans la colonne Actions.
3. Exécutez la commande suivante dans la section Terminal du conteneur sleep pour accéder au chemin /headers de l'application HTTPBin :
```
curl httpbin.foo.svc.cluster.local:8000/headers
```
  Sortie attendue :
```
{
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.foo.svc.cluster.local:8000",
    "User-Agent": "curl/7.82.0-DEV",
    "X-Envoy-Attempt-Count": "1",
    "X-Forwarded-Client-Cert": "By=spiffe://cluster.local/ns/foo/sa/httpbin;Hash=f7ab4985563b5b1986314d5a36c6e46819213e2f38301f534f00afb7cd4b9164;Subject=\"\";URI=spiffe://cluster.local/ns/foo/sa/sleep"
  }
}
```
4. Exécutez la commande suivante dans la section Terminal du conteneur sleep pour accéder au chemin /ip de l'application HTTPBin :
```
curl httpbin.foo.svc.cluster.local:8000/ip
```
  Le code 403 est renvoyé, ce qui indique que la requête est rejetée.
Les résultats de sortie indiquent que les applications du namespace default ne peuvent pas accéder aux chemins de l'application HTTPBin dans le namespace foo. Les applications du namespace foo peuvent accéder au chemin /headers de l'application HTTPBin.

Scénario 2 : Contrôler la méthode de requête et l'accès à un chemin spécifique d'une charge de travail

Dans cet exemple, une politique d'autorisation est créée pour spécifier que les applications situées dans des namespaces autres que foo peuvent accéder uniquement au chemin /status de l'application HTTPBin en utilisant des requêtes GET. L'application HTTPBin réside dans le namespace foo. Les requêtes vers d'autres chemins de l'application HTTPBin et les requêtes utilisant une méthode autre que GET échouent.

Étape 1 : Activer l'injection automatique du proxy sidecar pour les namespaces default et foo

Créez les namespaces default et foo. Pour plus d'informations, consultez la rubrique Créer un namespace.
Activez l'injection automatique du proxy sidecar pour les namespaces default et foo. Pour plus d'informations, consultez la rubrique Activer l'injection automatique du proxy sidecar.

Étape 2 : Déployer les applications de test

Déployez l'application sleep dans les namespaces default et foo.

Créez un fichier sleep.yaml contenant le contenu suivant :

Show the sleep.yaml file

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

Exécutez la commande suivante pour déployer l'application sleep dans le namespace default :
```
kubectl apply -f sleep.yaml -n default
```
Exécutez la commande suivante pour déployer l'application sleep dans le namespace foo :
```
kubectl apply -f sleep.yaml -n foo
```

Déployez l'application HTTPBin dans le namespace foo.

Créez un fichier httpbin.yaml contenant le contenu suivant :

Show the httpbin.yaml file

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

Exécutez la commande suivante pour déployer l'application HTTPBin dans le namespace foo :
```
kubectl apply -f httpbin.yaml -n foo
```

Étape 3 : Créer une politique d'autorisation

Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.
Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez Mesh Security Center > AuthorizationPolicy. Sur la page qui s'affiche, cliquez sur Create.
Sur la page Create, configurez les paramètres et cliquez sur Create.

Paramètre	Description
Name	Nom de la politique d'autorisation.
Policy Type	Sélectionnez ALLOW.
Namespaces	Dans l'onglet Workload Scope, définissez Namespaces sur foo.
Effective Scope	Sélectionnez Service.
Workload	Sélectionnez httpbin.
Request Matching Rules	Dans la section Add Request Target, configurez les paramètres suivants : Activez le commutateur Methods et définissez la valeur sur `GET`. Activez le commutateur Paths et définissez la valeur sur `/status/*`. Cela permet aux applications de tous les namespaces d'utiliser uniquement la méthode GET pour accéder au chemin /status de l'application httpbin dans le namespace foo.

Étape 4 : Vérifier si la politique d'autorisation contrôlant la méthode de requête et l'accès au chemin spécifique d'une charge de travail prend effet

Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Pods.
En haut de la page Pods, définissez Namespaces sur default. Recherchez le pod sleep et cliquez sur Terminal > sleep dans la colonne Actions.
Exécutez la commande suivante dans la section Terminal du conteneur sleep pour accéder au chemin /status de l'application HTTPBin en utilisant une requête POST :
```
curl -I -X POST "httpbin.foo.svc.cluster.local:8000/status/200" -H "accept: text/plain"
```
Le code 403 est renvoyé, ce qui indique que la requête est rejetée.
Exécutez la commande suivante pour accéder au chemin /IP de l'application HTTPBin en utilisant une requête GET :
```
curl -I -X GET "httpbin.foo.svc.cluster.local:8000/IP/200" -H "accept: text/plain"
```
Le code 403 est renvoyé, ce qui indique que la requête est rejetée.
Exécutez la commande suivante pour accéder au chemin /status de l'application HTTPBin en utilisant une requête GET :
```
curl -I -X GET "httpbin.foo.svc.cluster.local:8000/status/200" -H "accept: text/plain"
```
Sortie attendue :
```
HTTP/1.1 200 OK
server: envoy
date: Fri, 29 Apr 2022 03:01:16 GMT
content-type: text/html; charset=utf-8
access-control-allow-origin: *
access-control-allow-credentials: true
content-length: 0
x-envoy-upstream-service-time: 5
```
Le résultat indique que les applications du namespace default peuvent accéder au chemin /status de l'application HTTPBin uniquement en utilisant des requêtes GET. Cela signifie que la politique d'autorisation prend effet.

Exemple 3 : Contrôler l'accès à une charge de travail par adresses IP client

Vous pouvez créer une politique d'autorisation qui permet uniquement aux requêtes provenant d'adresses IP client autorisées d'accéder à l'application HTTPBin dans le namespace foo.

Étape 1 : Activer l'injection automatique du proxy sidecar pour le namespace foo

Créez le namespace foo. Pour plus d'informations, consultez la rubrique Gérer les namespaces globaux.
Activez l'injection automatique du proxy sidecar pour le namespace foo. Pour plus d'informations, consultez la rubrique Activer l'injection automatique du proxy sidecar.

Étape 2 : Déployer une passerelle d'entrée

Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.
Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez ASM Gateways > Ingress Gateway.

Sur la page Ingress Gateway, cliquez sur Create, configurez les paramètres, puis cliquez sur Create.

Paramètre	Description
Name	Nom de la passerelle d'entrée.
Cluster	Cluster dans lequel vous souhaitez déployer la passerelle d'entrée.
SLB	Sélectionnez Classic Load Balancer et Public Access. Cet exemple utilise un Classic Load Balancer, mais vous pouvez également utiliser un Network Load Balancer.
Create SLB Instance	Instance d'équilibreur de charge que vous souhaitez utiliser. Vous pouvez sélectionner une instance d'équilibreur de charge en utilisant l'une des méthodes suivantes : Use Existing CLB Instance : sélectionnez un équilibreur de charge existant dans la liste. Create SLB Instance : cliquez sur Create SLB Instance et sélectionnez les spécifications souhaitées dans la liste déroulante.
Port Mapping	Sélectionnez un Protocol et saisissez un Service Port selon vos besoins.
External Traffic Policy	Cliquez sur Advanced Options et définissez External Traffic Policy sur Local.

Étape 3 : Créer un service virtuel et une passerelle Istio

Utilisez le contenu suivant pour créer un service virtuel dans le namespace foo. Pour plus d'informations, consultez la rubrique Gérer les services virtuels.

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: httpbin
spec:
  gateways:
    - httpbin-gateway
  hosts:
    - '*'
  http:
    - match:
        - uri:
            prefix: /headers
      route:
        - destination:
            host: httpbin
            port:
              number: 8000

Utilisez le contenu suivant pour créer une passerelle Istio dans le namespace foo. Pour plus d'informations, consultez la rubrique Gérer les passerelles Istio.

apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: httpbin-gateway
spec:
  selector:
    istio: ingressgateway
  servers:
    - hosts:
        - '*'
      port:
        name: http
        number: 80
        protocol: HTTP

Étape 4 : Créer une politique d'autorisation

Obtenez l'adresse IP de la passerelle d'entrée. Pour plus d'informations, consultez la rubrique Créer une passerelle d'entrée.

Obtenez l'adresse IP du client.

Saisissez http://{ASM Gateway IP}/headers dans la barre d'adresse de votre navigateur pour obtenir l'adresse IP pour X-Envoy-External-Address. Dans la réponse renvoyée, le champ X-Envoy-External-Address correspond à l'adresse IP externe réelle du client.

{
  "headers": {
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,imag...",
    "Accept-Encoding": "gzip, deflate",
    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
    "Cache-Control": "max-age=0",
    "Host": "<IP address>",
    "Upgrade-Insecure-Requests": "1",
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.3...",
    "X-Envoy-Attempt-Count": "1",
    "X-Envoy-External-Address": "<Client external IP>",
    "X-Forwarded-Client-Cert": "By=spiffe://cluster.local/ns/foo/sa/httpbin;Hash=e49...service-account"
  }
}

Créez une politique d'autorisation.

Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.
Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez Mesh Security Center > AuthorizationPolicy. Sur la page qui s'affiche, cliquez sur Create.

Sur la page Create, configurez les paramètres et cliquez sur Create.

Paramètre	Description
Name	Nom de la politique d'autorisation.
Policy Type	Sélectionnez DENY.
Namespaces	Dans l'onglet Workload Scope, définissez Namespaces sur foo.
Effective Scope	Sélectionnez Service.
Workload	Sélectionnez httpbin.
Request Matching Rules	Dans la section Add Request Source, activez le commutateur RemoteIPBlocks et définissez la valeur sur l'adresse IP client obtenue lors de l'étape précédente. Cela empêche l'adresse IP client d'accéder à l'application `httpbin`.

Étape 5 : Vérifier si la politique d'autorisation refusant les requêtes envoyées depuis l'adresse IP client spécifiée prend effet

Dans votre navigateur, accédez à http://{ASM gateway IP}/headers. Le message RBAC: access denied est renvoyé, indiquant que l'accès à l'application httpbin a échoué. Cela confirme que la restriction sur l'adresse IP client est effective.

RBAC: access denied

Exemple 4 : Contrôler l'accès aux services entre les namespaces

Étape 1 : Activer l'injection automatique du proxy sidecar pour les namespaces demo-frontend et demo-server

Créez les namespaces demo-frontend et demo-server. Pour plus d'informations, consultez la rubrique Créer un namespace.
Activez l'injection automatique du proxy sidecar pour les namespaces demo-frontend et demo-server. Pour plus d'informations, consultez la section « Activer l'injection automatique du proxy sidecar » de la rubrique Gérer les namespaces globaux.

Étape 2 : Déployer les services de test

Créez un service nommé sleep dans le namespace demo-frontend et un service nommé httpbin dans le namespace demo-server. Le service sleep est utilisé pour envoyer des requêtes afin d'accéder au service httpbin.

Créez un service nommé sleep dans le namespace demo-frontend.

Créez un fichier sleep.yaml contenant le contenu suivant :

Show the sleep.yaml file

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

Utilisez kubectl pour vous connecter au cluster Container Service for Kubernetes (ACK) en vous basant sur les informations du fichier kubeconfig, puis exécutez la commande suivante pour créer un service sleep :
```
kubectl apply -f sleep.yaml -n demo-frontend
```

Créez un service nommé httpbin dans le namespace demo-server.

Créez un fichier httpbin.yaml contenant le contenu suivant :

Show the httpbin.yaml file

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

Utilisez kubectl pour vous connecter au cluster ACK en vous basant sur les informations du fichier kubeconfig, puis exécutez la commande suivante pour créer un service httpbin :
```
kubectl apply -f httpbin.yaml -n demo-server
```

Vérifiez que les proxies sidecar sont injectés dans les pods où résident les services sleep et httpbin.
1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Pods.
3. En haut de la page Pods, sélectionnez demo-frontend dans la liste déroulante Namespaces et cliquez sur le nom du pod du service sleep.
  
  Dans l'onglet Containers, vous pouvez voir le conteneur istio-proxy. Cela indique que l'injection sidecar pour le service sleep est terminée.
4. En haut de la page Pods, sélectionnez demo-server dans la liste déroulante Namespaces et cliquez sur le nom du pod du service httpbin.
  
  Dans l'onglet Containers, vous pouvez voir le conteneur istio-proxy. Cela indique que l'injection sidecar pour le service httpbin est terminée.

Étape 3 : Créer une politique d'autorisation pour contrôler l'accès aux services entre les namespaces

Vous pouvez créer une politique d'autorisation et modifier le paramètre action dans cette politique pour refuser ou autoriser les requêtes d'accès des services du namespace demo-frontend vers les services du namespace demo-server. Ainsi, vous pouvez contrôler l'accès aux services entre les namespaces.

Créez une politique d'autorisation pour refuser les requêtes d'accès du namespace demo-frontend vers le namespace demo-server.

Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.
Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez Mesh Security Center > AuthorizationPolicy. Sur la page qui s'affiche, cliquez sur Create.

Configurez les paramètres de la politique d'autorisation et cliquez sur Create.

Paramètre	Description
Name	Nom de la politique d'autorisation.
Policy Type	Sélectionnez DENY.
Namespaces	Dans l'onglet Workload Scope, définissez Namespaces sur `demo-server`.
Effective Scope	Sélectionnez Namespace Scope.
Request Matching Rules	Dans la section Add Request Source, activez le commutateur Namespaces et définissez la valeur sur demo-frontend.

Accédez au service httpbin.
1. Connectez-vous à la console ACK. Dans le volet de navigation de gauche, cliquez sur Clusters.
2. Sur la page Clusters, cliquez sur le nom de votre cluster. Dans le volet de navigation de gauche, cliquez sur Workloads > Pods.
3. En haut de la page Pods, sélectionnez demo-frontend dans la liste déroulante Namespaces. Ensuite, recherchez le pod sleep et cliquez sur Terminal > sleep dans la colonne Actions.
4. Exécutez la commande suivante sur le terminal du conteneur sleep pour accéder au service httpbin :
```
curl -I httpbin.demo-server.svc.cluster.local:8000
```
  Sortie attendue :
```
HTTP/1.1 403 Forbidden
content-length: 19
content-type: text/plain
date: Wed, 11 Oct 2023 08:15:25 GMT
server: envoy
x-envoy-upstream-service-time: 4
```
  La sortie précédente indique que les services du namespace demo-frontend n'ont pas pu accéder aux services du namespace demo-server.
Modifiez la valeur du paramètre action dans la politique d'autorisation sur ALLOW pour autoriser les requêtes d'accès du namespace demo-frontend vers le namespace demo-server.
1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.
2. Sur la page Mesh Management, cliquez sur le nom de l'instance ASM. Dans le volet de navigation de gauche, sélectionnez Mesh Security Center > AuthorizationPolicy.
3. Sur la page AuthorizationPolicy, recherchez la politique cible et cliquez sur View YAML dans la colonne Actions.
4. Dans la boîte de dialogue Edit, modifiez la valeur du paramètre action sur ALLOW et cliquez sur OK.
Exécutez la commande suivante sur le terminal du conteneur sleep pour accéder au service httpbin :
```
curl -I httpbin.demo-server.svc.cluster.local:8000
```
Sortie attendue :
```
HTTP/1.1 200 OK
server: envoy
date: Wed, 11 Oct 2023 08:21:40 GMT
content-type: text/html; charset=utf-8
content-length: 9593
access-control-allow-origin: *
access-control-allow-credentials: true
x-envoy-upstream-service-time: 13
```
La sortie précédente indique que les services du namespace demo-frontend ont réussi à accéder aux services du namespace demo-server.

Comme vous pouvez le constater, après la création d'une politique d'autorisation avec l'Action définie sur Deny, les services du namespace demo-frontend ne parviennent pas à accéder aux services du namespace demo-server. Après avoir modifié l'Action de la politique d'autorisation sur ALLOW, les services du namespace demo-frontend peuvent accéder avec succès aux services du namespace demo-server. Cela indique que la politique d'autorisation contrôle efficacement l'accès aux services entre les namespaces.