Alibaba Cloud Service Mesh:Configurer une politique d'autorisation pour le trafic TCP

Prérequis

• Le cluster est ajouté à l'instance ASM.

• Les ressources Istio sont définies. Pour plus d'informations, consultez la rubrique Utiliser des ressources Istio pour router le trafic en fonction de la version.

• Le namespace foo est créé et l'injection du proxy sidecar est activée. Pour plus d'informations, consultez les rubriques Créer un namespace et Activer l'injection automatique.

Étape 1 : Déployer les exemples d'applications

Déployez tcp-echo en tant que service TCP cible qui reçoit les requêtes, et sleep en tant que service client TCP qui envoie les requêtes.

1. Déployez le service TCP cible.

   1. Créez un fichier tcp-echo.yaml avec le contenu suivant :

      Lorsque le service tcp-echo reçoit une requête, il ajoute le préfixe hello au contenu de la requête et renvoie le résultat. Par exemple, si vous envoyez world à tcp-echo, le service renvoie hello world.

      tcp-echo.yaml

      apiVersion: v1
      kind: Service
      metadata:
        name: tcp-echo
        labels:
          app: tcp-echo
          service: tcp-echo
      spec:
        ports:
        - name: tcp
          port: 9000
        - name: tcp-other
          port: 9001
        selector:
          app: tcp-echo
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: tcp-echo
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: tcp-echo
            version: v1
        template:
          metadata:
            labels:
              app: tcp-echo
              version: v1
          spec:
            containers:
            - name: tcp-echo
              image: docker.io/istio/tcp-echo-server:1.2
              imagePullPolicy: IfNotPresent
              args: [ "9000,9001,9002", "hello" ]
              ports:
              - containerPort: 9000
              - containerPort: 9001

   2. Connectez-vous au cluster avec kubectl et exécutez la commande suivante pour déployer le service tcp-echo dans le namespace foo.

      Pour savoir comment utiliser kubectl pour se connecter à un cluster, consultez la rubrique Obtenir le fichier kubeconfig d'un cluster et utiliser kubectl pour s'y connecter.

      kubectl apply -f tcp-echo.yaml -n foo

2. Déployez le service client TCP.

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

      sleep.yaml

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

   2. Exécutez la commande suivante pour déployer le service sleep dans le namespace foo.

      kubectl apply -f sleep.yaml -n foo

Étape 2 : Vérifier la connexion avant l'autorisation

Avant de créer la politique d'autorisation, vérifiez que le service sleep peut atteindre les deux ports du service tcp-echo. Ces résultats constituent la base de référence pour la vérification effectuée à l'étape 4.

1. Exécutez la commande suivante pour vérifier que le service sleep peut accéder au service tcp-echo sur le port 9001.

   kubectl exec "$(kubectl get pod -l app=sleep -n foo -o jsonpath={.items..metadata.name})" -c sleep -n foo -- sh -c 'echo "port 9001" | nc tcp-echo 9001' | grep "hello" && echo 'connection succeeded' || echo 'connection rejected'

   Résultat attendu :

   hello port 9001
   connection succeeded

   Le résultat confirme que le service sleep peut accéder au service tcp-echo sur le port 9001.

2. Exécutez la commande suivante pour vérifier que le service sleep peut accéder au service tcp-echo sur le port 9000.

   kubectl exec "$(kubectl get pod -l app=sleep -n foo -o jsonpath={.items..metadata.name})" -c sleep -n foo -- sh -c 'echo "port 9000" | nc tcp-echo 9000' | grep "hello" && echo 'connection succeeded' || echo 'connection rejected'

   Résultat attendu :

   hello port 9000
   connection succeeded

   Le résultat confirme que le service sleep peut accéder au service tcp-echo sur le port 9000.

Étape 3 : Configurer la politique d'autorisation

Configurez une politique d'autorisation qui autorise l'accès au service tcp-echo sur le port 9000. La politique s'applique à l'ensemble du namespace foo et ses règles n'autorisent l'accès que sur le port 9000. L'accès sur le port 9001 est donc refusé après la création de la politique. Vous le vérifierez à l'étape 4.

1. Connectez-vous à la console ASM. Dans le volet de navigation de gauche, sélectionnez Service Mesh > Mesh Management.

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

2. Créez une politique d'autorisation en utilisant l'une des méthodes suivantes.

   Méthode 1 : Créer la politique d'autorisation à l'aide de YAML

   1. Sur la page AuthorizationPolicy, cliquez sur Create from YAML.

   2. Sur la page Create, définissez Namespaces sur foo, sélectionnez n'importe quel Scenario Template, collez le modèle YAML suivant dans la zone YAML, puis cliquez sur Create.

      kind: AuthorizationPolicy
      apiVersion: security.istio.io/v1beta1
      metadata:
        name: demo
        namespace: foo
      spec:
        action: ALLOW
        rules:
          - to:
              - operation:
                  ports:
                    - '9000'

   Méthode 2 : Créer la politique d'autorisation via l'interface utilisateur de la console

   Important

   Lorsque vous configurez une politique d'autorisation TCP, n'activez pas l'interrupteur Methods. Ce paramètre s'applique uniquement aux requêtes HTTP et ne crée pas de règle ALLOW valide pour le trafic TCP. Le Service Mesh ignore les règles ALLOW non valides, ce qui entraîne le refus des requêtes et le renvoi du message connection rejected.

   1. Sur la page AuthorizationPolicy, cliquez sur Create.

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

      Paramètre	Description
      Name	Dans cet exemple, saisissez demo.
      Policy Type	Sélectionnez ALLOW.
      Namespaces	Sous l'onglet Workload Scope, sélectionnez le namespace foo.
      Effective Scope	Sélectionnez Namespace Scope.
      Request Matching Rules	Dans la section Add Request Target, activez l'interrupteur Ports et définissez la valeur sur 9000.

Étape 4 : Vérifier la connexion après l'autorisation

Une fois la politique d'autorisation créée, exécutez les mêmes deux tests de connexion qu'à l'étape 2 et comparez les résultats.

1. Exécutez la commande suivante pour vérifier que l'accès au service tcp-echo sur le port 9001 est refusé.

   kubectl exec "$(kubectl get pod -l app=sleep -n foo -o jsonpath={.items..metadata.name})" -c sleep -n foo -- sh -c 'echo "port 9001" | nc tcp-echo 9001' | grep "hello" && echo 'connection succeeded' || echo 'connection rejected'

   Résultat attendu :

   connection rejected

   Le résultat connection rejected confirme que le service sleep ne peut plus accéder au service tcp-echo sur le port 9001.

2. Exécutez la commande suivante pour vérifier que l'accès au service tcp-echo sur le port 9000 est toujours autorisé.

   kubectl exec "$(kubectl get pod -l app=sleep -n foo -o jsonpath={.items..metadata.name})" -c sleep -n foo -- sh -c 'echo "port 9000" | nc tcp-echo 9000' | grep "hello" && echo 'connection succeeded' || echo 'connection rejected'

   Résultat attendu :

   hello port 9000
   connection succeeded

   Le port 9001 est refusé et le port 9000 reste accessible, ce qui confirme que la politique d'autorisation prend effet comme prévu.

Références

• Pour contrôler finement le trafic HTTP entre les services, consultez la rubrique Configurer une politique d'autorisation pour le trafic HTTP.

• Pour contrôler l'accès aux services situés en dehors du mesh, consultez les rubriques Contrôler l'accès depuis les services du mesh vers des sites web externes et Contrôler l'accès depuis les services du mesh vers des bases de données externes.

• Personnalisez le contenu des journaux d'accès de la passerelle ASM pour identifier rapidement les problèmes de sécurité potentiels. Pour plus d'informations, consultez la rubrique Générer et collecter les journaux d'accès de la passerelle ASM.

• Activez l'audit du mesh pour enregistrer et tracer les opérations quotidiennes des différents utilisateurs. Configurez également des alertes d'audit pour les opérations sur les ressources du mesh, qui envoient des notifications d'alerte aux contacts d'alerte lorsque des ressources critiques sont modifiées. Pour plus d'informations, consultez les rubriques Utiliser l'audit des opérations KubeAPI et Configurer des alertes d'audit pour les opérations sur les ressources du mesh.