Contrôler le trafic sortant vers un site web externe à l'aide d'une politique d'autorisation - Alibaba Cloud Service Mesh

Dans un cluster Kubernetes, une NetworkPolicy peut contrôler quels services d'un namespace sont autorisés à accéder à des sites web externes spécifiques. Toutefois, une NetworkPolicy offre une isolation réseau à grain grossier qui peut s'avérer insuffisante pour garantir la sécurité des applications ou des activités métier. Utilisez Alibaba Cloud Service Mesh (ASM) pour configurer dynamiquement une politique d'autorisation permettant un contrôle fin des accès sortants et réduire les risques de sécurité. Cette rubrique explique comment bloquer l'accès au site web externe aliyun.com pour tous les services du namespace demo-frontend.

Prérequis

Le cluster est ajouté à l'instance ASM. Pour plus d'informations, consultez la rubrique Ajouter un cluster à une instance ASM.
Un namespace nommé demo-frontend a été créé et l'injection du proxy sidecar y a été activée. Pour plus d'informations, consultez la rubrique Gérer les namespaces globaux.

Étape 1 : Créer un service de test

Obtenir le fichier kubeconfig du cluster et utiliser kubectl pour se connecter au cluster.

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

Créez un fichier nommé sleep.yaml contenant le code suivant.

sleep.yaml

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 créer le service sleep.
```
kubectl apply -f sleep.yaml -n demo-frontend
```

Vérifiez qu'un proxy sidecar a bien été injecté dans le service de test.
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 Namespace et cliquez sur le nom du pod exécutant le service sleep.
  
  Sous l'onglet Containers, vous trouverez un conteneur nommé istio-proxy. Cela confirme que l'injection du proxy sidecar a réussi.

Étape 2 : Créer une passerelle de sortie

Lorsque les services d'un Service Mesh accèdent à des sites web situés en dehors du maillage, utilisez une passerelle de sortie pour gérer le trafic. Après avoir configuré une politique d'autorisation pour la passerelle de sortie, définissez des conditions afin de contrôler l'accès aux sites web externes. Dans cette rubrique, la passerelle de sortie est nommée egressgateway. Pour plus d'informations, consultez la rubrique Créer une passerelle de sortie.

Étape 3 : Configurer la politique de trafic sortant

Par défaut, les services d'un maillage de services peuvent accéder à tous les services externes. Pour contrôler l'accès à des sites web externes spécifiques, définissez la politique de trafic sortant sur REGISTRY_ONLY. Ainsi, les services du Service Mesh ne pourront accéder qu'aux services externes enregistrés en tant que ServiceEntry.

Configurez la politique de trafic sortant.
1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, choisissez 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, choisissez Data Plane Component Management > Configure the agent parameters of the injected Sidecar.
3. Sous l'onglet global, cliquez sur Outbound Traffic Policy, définissez la valeur de Outbound Traffic Policy sur REGISTRY_ONLY, puis cliquez sur Update Settings.
Enregistrez le service externe en tant que ServiceEntry.
1. Sur la page des détails de l'instance ASM, choisissez Cluster & Workload Management > External Service(ServiceEntry) dans le volet de navigation de gauche. Sur la page qui s'affiche, cliquez sur Create from YAML.
2. Définissez le paramètre Namespace sur istio-system, copiez le contenu suivant dans la zone de texte, puis cliquez sur Create.
```
apiVersion: networking.istio.io/v1beta1
kind: ServiceEntry
metadata:
  name: aliyuncom-ext
  namespace: istio-system
spec:
  hosts:
    - www.aliyun.com  
  location: MESH_EXTERNAL
  ports:
    - name: http
      number: 80
      protocol: HTTP
    - name: tls
      number: 443
      protocol: TLS
  resolution: DNS
```

Étape 4 : Créer des politiques de trafic

Créez une règle de passerelle, une règle de destination et un service virtuel pour acheminer le trafic du namespace demo-frontend vers la passerelle de sortie, qui le redirigera ensuite vers le site web externe.

Utilisez le contenu YAML suivant pour créer une règle de passerelle dans le namespace istio-system. Pour plus d'informations, consultez la rubrique Gérer les règles de passerelle.
```
apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: istio-egressgateway
  namespace: istio-system
spec:
  selector:
    istio: egressgateway
  servers:
    - port:
        number: 80
        name: http
        protocol: HTTPS
      tls:
        mode: ISTIO_MUTUAL
      hosts:
        - '*'
```
La définition du paramètre mode sur ISTIO_MUTUAL active l'authentification mutuelle TLS (mTLS). Les services au sein du maillage doivent ainsi utiliser l'authentification mTLS lors de l'envoi du trafic via la passerelle de sortie.
Utilisez le contenu YAML suivant pour créer une règle de destination dans le namespace demo-frontend. Pour plus d'informations, consultez la rubrique Gérer les règles de destination.
```
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: target-egress-gateway
  namespace: demo-frontend
spec:
  host: istio-egressgateway.istio-system.svc.cluster.local
  subsets:
    - name: target-egress-gateway-mTLS
      trafficPolicy:
        loadBalancer:
          simple: ROUND_ROBIN
        tls:
          mode: ISTIO_MUTUAL
```
La définition du paramètre mode sur ISTIO_MUTUAL active l'authentification mutuelle TLS (mTLS). Le protocole mTLS est requis pour le trafic à destination de la passerelle de sortie.

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

VirtualService YAML

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: example-com-through-egress-gateway
  namespace: demo-frontend
spec:
  exportTo:
    - istio-system
    - demo-frontend
  gateways:
    - mesh
    - istio-system/istio-egressgateway
  hosts:
    - www.aliyun.com
  http:
    - match:
        - gateways:
            - mesh
          port: 80
      route:
        - destination:
            host: istio-egressgateway.istio-system.svc.cluster.local
            port:
              number: 80
            subset: target-egress-gateway-mTLS
          weight: 100
    - match:
        - gateways:
            - istio-system/istio-egressgateway
          port: 80
      route:
        - destination:
            host: www.aliyun.com
            port:
              number: 80
          weight: 100

La section http définit deux règles de correspondance :

La première règle définit le paramètre gateways sur mesh. Elle s'applique aux proxies sidecar du namespace demo-frontend et permet d'acheminer le trafic de ce namespace vers la passerelle de sortie.
La seconde règle définit le paramètre gateways sur istio-system/istio-egressgateway. Elle permet d'acheminer le trafic depuis la passerelle de sortie vers le service externe enregistré.

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

Créez une politique d'autorisation dans le namespace demo-frontend qui s'applique à la ressource egressgateway afin de refuser les requêtes provenant de ce namespace.

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

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

Parameter

Description

Name

Saisissez un nom pour la politique d'autorisation.

Policy Type

Sélectionnez l'option DENY.

ASM Gateway

Sous l'onglet Gateway Scope, définissez le paramètre ASM Gateway sur egressgateway.

Request Matching Rules

Dans la section Add Request Source, activez l'option Namespaces et saisissez la valeur demo-frontend.

Étape 6 : Vérifier le contrôle d'accès

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, sélectionnez demo-frontend dans la liste déroulante Namespace. Dans la colonne Actions correspondant au pod sleep, cliquez sur Terminal > sleep.
Exécutez la commande suivante pour accéder au site web externe aliyun.com.
```
curl -I http://www.aliyun.com
```
Résultat attendu :
```
HTTP/1.1 403 Forbidden
content-length: 19
content-type: text/plain
date: Thu, 12 Oct 2023 07:14:09 GMT
server: envoy
x-envoy-upstream-service-time: 4
```
La réponse 403 Forbidden indique que la politique d'autorisation a bien bloqué la requête envoyée depuis le namespace demo-frontend vers le site web externe aliyun.com.