2
votes

Essayer de configurer une entrée avec tls et ouvrir à certaines IP uniquement sur GKE

J'ai du mal à configurer une entrée ouverte uniquement à certaines adresses IP spécifiques, j'ai vérifié des documents, j'ai essayé beaucoup de choses et une adresse IP hors de la source continue d'accéder. c'est une interface Web Zabbix sur un alpin avec nginx, configurer un service sur le nœud-port 80 puis utiliser une entrée pour configurer un équilibreur de charge sur GCP, tout fonctionne, l'interface Web fonctionne bien, mais comment puis-je le rendre accessible uniquement aux adresses IP souhaitées? mes règles de pare-feu sont correctes et elles ne sont accessibles que via l'adresse IP de l'équilibreur de charge

De plus, j'ai un espace de noms spécifique pour ce déploiement.

Version du cluster 1.11.5-gke.5 MODIFIER J'utilise le GLBC d'entrée standard de GKE

Mon modèle est configuré comme suit: quelqu'un peut-il m'aider à m'éclairer sur ce qui manque:

    apiVersion: v1
    kind: ReplicationController
    metadata:
      name: zabbix-web
      namespace: zabbix-prod
      labels:
        app: zabbix
        tier: frontend
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            name: zabbix-web
            app: zabbix
        spec:
          volumes:
          - name: cloudsql-instance-credentials
            secret:
              defaultMode: 420
              secretName: cloudsql-instance-credentials
          containers:
            - command:
              - /cloud_sql_proxy
              - -instances=<conection>
              - -credential_file=/secrets/cloudsql/credentials.json
              image: gcr.io/cloudsql-docker/gce-proxy:1.11
              imagePullPolicy: IfNotPresent
              name: cloudsql-proxy
              resources: {}
              securityContext:
                allowPrivilegeEscalation: false
                runAsUser: 2
              terminationMessagePath: /dev/termination-log
              terminationMessagePolicy: File
              volumeMounts:
              - mountPath: /secrets/cloudsql
                name: credentials
                readOnly: true
            - name: zabbix-web
              image: zabbix/zabbix-web-nginx-mysql:alpine-3.2-latest
              ports:
              - containerPort: 80
              env:
              - name: MYSQL_USER
                valueFrom:
                  secretKeyRef:
                    key: <user>
                    name: <user>
              - name: MYSQL_PASSWORD
                valueFrom:
                  secretKeyRef:
                    key: <pass>
                    name: <pass>
              - name: DB_SERVER_HOST
                value: 127.0.0.1
              - name: MYSQL_DATABASE
                value: <db>
              - name: ZBX_SERVER_HOST
                value: <db>
            readinessProbe:
              failureThreshold: 3
              httpGet:
                path: /index.php
                port: 80
                scheme: HTTP
              periodSeconds: 10
              successThreshold: 1
              timeoutSeconds: 30
---
apiVersion: v1
kind: Service
metadata:
  name: "zabbix-web-service"
  namespace: "zabbix-prod"
  labels:
    app: zabbix
spec:
  ports:
  - port: 80
    targetPort: 80
  selector:
    name: "zabbix-web"
  type: "NodePort"
---
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: zabbix-web-ingress
  namespace: zabbix-prod
  annotations:
    ingress.kubernetes.io/service.spec.externalTrafficPolicy: local
    ingress.kubernetes.io/whitelist-source-range: <xxx.xxx.xxx.xxx/32>
spec:
  tls:
  - secretName: <tls-cert>
  backend:
    serviceName: zabbix-web-service
    servicePort: 80


2 commentaires

Quel contrôleur d'entrée utilisez-vous?


Entrée GLBC (norme GKE)


4 Réponses :


0
votes

AFAIK, vous ne pouvez pas restreindre les adresses IP via GLBC ou sur GCP L7 Load Balancer lui-même . Notez que GLBC est également un travail en cours au moment de la rédaction de cet article.

ingress.kubernetes.io/whitelist-source-range fonctionne très bien, mais lorsque vous utilisez quelque chose comme un contrôleur d'entrée nginx car nginx lui-même peut restreindre les adresses IP .

La manière générale de restreindre / mettre en liste blanche les adresses IP consiste à utiliser Règles de pare-feu VPC ( ce qui semble que vous faites déjà). Essentiellement, vous pouvez restreindre / ajouter les adresses IP au réseau sur lequel vos nœuds K8 sont exécutés.


0 commentaires

0
votes

L'une des meilleures options pour atteindre votre objectif consiste à utiliser des règles de pare-feu, car vous ne pouvez pas restreindre les adresses IP via Global LB ou sur GCP L7 LB lui-même. Cependant, une autre option si vous utilisez Ingress sur votre cluster Kubernetes , il est possible de restreindre l'accès à votre application en fonction d'adresses IP dédiées.

Un cas d'utilisation possible serait que vous ayez une configuration de développement et que vous ne vouliez pas rendre toutes les nouvelles fonctionnalités sophistiquées disponibles à tout le monde, en particulier à vos concurrents. Dans ce cas, la liste blanche d'adresses IP pour restreindre l'accès peut être utilisée.

Cela peut être fait en spécifiant les plages de sources IP client autorisées via l'annotation ingress.kubernetes.io/whitelist-source-range .

La valeur est une liste de blocs CIDR séparés par des virgules.

Par exemple:

10.0.0.0/24, 1.1.1.1/32.

Veuillez obtenir plus d'informations ici .


0 commentaires

0
votes

Pour quiconque tombe sur cette question via Google comme moi, il existe désormais une solution. Vous pouvez mettre en œuvre cela via un BackendConfig de l'API Kubernetes cloud.google.com en conjonction avec une règle GCE CloudArmor.

https://cloud.google.com / kubernetes-engine / docs / how-to / cloud-armor-backendconfig


0 commentaires

0
votes

Vous pouvez ajouter des adresses IP à la liste blanche en en configurant Ingress et Cloud Armure :

Passer au projet:

metadata:
  namespace: <namespace>
  name: <service-name>
  labels:
    app: my-app
  annotations:
    cloud.google.com/backend-config: '{"ports": {"80":"backendconfig-name"}}'
spec:
  type: NodePort
  selector:
    app: hello-app
  ports:
  - port: 80
    protocol: TCP
    targetPort: 8080

Créer une politique:

# File backendconfig.yaml:
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
  namespace: <namespace>
  name: <name>
spec:
  securityPolicy:
    name: $POLICY_NAME

$ kubectl apply -f backendconfig.yaml
backendconfig.cloud.google.com/backendconfig-name created

Modifier la politique par défaut pour refuser:

gcloud compute security-policies delete $POLICY_NAME

Sur une priorité inférieure à la liste blanche par défaut, toutes les adresses IP que vous souhaitez ajouter à la liste blanche:

gcloud compute security-policies rules delete $PRIORITY --security-policy $POLICY_NAME

Avec un maximum de dix par plage.

Notez que vous avez besoin de plages CIDR valides, pour cela vous pouvez utiliser CIDR pour Plage d'adresses IP -> Plage d'adresses IP à CIDR .

Affichez la stratégie comme suit:

gcloud compute security-policies describe $POLICY_NAME

Pour supprimer une entrée: p >

gcloud compute security-policies rules create 2 \
  --action allow \
  --security-policy $POLICY_NAME \
  --description "allow friends" \
  --src-ip-ranges "93.184.17.0/24,151.101.1.69/32"

ou le règlement complet:

gcloud compute security-policies rules update 2147483647 --action=deny-403 \ 
  --security-policy $POLICY_NAME

Créez un BackendConfig pour la politique:

gcloud compute security-policies create $POLICY_NAME --description "whitelisting"

Ajoutez le BackendConfig vers Service :

gcloud config set project $PROJECT


0 commentaires