Citrix ADC Ingress Controller

Verwenden von Citrix ADC-Anmeldeinformationen, die in einem Tresor-Server für den Citrix Ingress Controller gespeichert sind

In den meisten Organisationen werden Citrix ADC Ingress-Geräte der Stufe 1 und Kubernetes-Cluster von separaten Teams verwaltet. Normalerweise verwalten Netzwerkadministratoren Citrix ADC Ingress-Geräte der Stufe 1, während Entwickler Kubernetes-Cluster verwalten. Der Citrix Ingress Controller benötigt Citrix ADC-Anmeldeinformationen wie Citrix ADC-Benutzernamen und -Kennwort, um den Citrix ADC zu konfigurieren. Sie können Citrix ADC-Anmeldeinformationen als Teil der Citrix Ingress Controller-Spezifikation angeben und die ADC-Anmeldeinformationen als Kubernetes-Geheimnisse speichern. Sie können jedoch auch Citrix ADC-Anmeldeinformationen in einem Tresor-Server speichern und Anmeldeinformationen an den Citrix Ingress Controller übergeben, um Sicherheitsrisiken zu minimieren. Dieses Thema enthält Informationen zur Verwendung von Citrix ADC-Anmeldeinformationen, die auf einem Tresor-Server für den Citrix Ingress Controller gespeichert sind.

Im folgenden Diagramm werden die Schritte zur Verwendung von Citrix ADC-Anmeldeinformationen erläutert, die auf einem Tresor-Server mit dem Citrix Ingress Controller gespeichert sind.

vault-auto-authentication

Voraussetzungen

Stellen Sie sicher, dass Sie einen Tresor-Server eingerichtet und den geheimen Schlüsselwertspeicher (KV) aktiviert haben. Weitere Informationen finden Sie in der Vault-Dokumentation.

Verwenden von Citrix ADC-Anmeldeinformationen von einem Tresor-Server für den Citrix Ingress Controller

Führen Sie die folgenden Aufgaben aus, um Citrix ADC-Anmeldeinformationen von einem Tresor-Server für den Citrix Ingress Controller zu verwenden.

  1. Erstellen Sie ein Dienstkonto für die Kubernetes-Authentifizierung.

  2. Erstellen Sie ein Key Vault-Geheimnis und richten Sie die Kubernetes-Authentifizierung auf dem Tresor-Serverein

  3. Nutzen Sie die Vault Auto-Auth -Funktionalität, um Citrix ADC-Anmeldeinformationen für den Citrix Ingress Controller abzurufen.

Erstellen Sie ein Dienstkonto für die Kubernetes-Authentifizierung

Erstellen Sie ein Dienstkonto für die Kubernetes-Authentifizierung, indem Sie die folgenden Schritte ausführen:

  1. Erstellen Sie ein Dienstkonto cic-k8s-role und geben Sie mithilfe des folgenden Befehls das Dienstkonto an, das für den Zugriff auf die Kubernetes TokenReview-API erforderlich ist.

    $ kubectl apply -f cic-k8s-role-service-account.yml
             
            
    serviceaccount/cic-k8s-role created
    clusterrole.rbac.authorization.k8s.io/cic-k8s-role configured
    clusterrolebinding.rbac.authorization.k8s.io/cic-k8s-role configured
    clusterrolebinding.rbac.authorization.k8s.io/role-tokenreview-binding configured
    

    Following is a part of the sample cic-k8s-role-service-account.yml file.

    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata:
    name: role-tokenreview-binding
    namespace: default
    roleRef:
    apiGroup: rbac.authorization.k8s.io
    kind: ClusterRole
    name: system:auth-delegator
    subjects:
    - kind: ServiceAccount
    name: cic-k8s-role
    namespace: default
    
  2. Setzen Sie die VAULT_SA_NAME Umgebungsvariable auf den Namen des Dienstkontos, das Sie bereits erstellt haben.

         export VAULT_SA_NAME=$(kubectl get sa cic-k8s-role -o jsonpath="{.secrets[*]['name']}")
    <!--NeedCopy-->
    
  3. Legen Sie die SA_JWT_TOKEN Umgebungsvariable auf das JWT des Dienstkontos fest, mit dem Sie auf die TokenReview-API zugegriffen haben.

         export SA_JWT_TOKEN=$(kubectl get secret $VAULT_SA_NAME -o jsonpath="{.data.token}" | base64 --decode; echo)
    <!--NeedCopy-->
    
  4. Holen Sie sich ein von Kubernetes CA signiertes Zertifikat, um mit der Kubernetes-API zu kommunizieren.

         export SA_CA_CRT=$(kubectl get secret $VAULT_SA_NAME -o jsonpath="{.data['ca.crt']}" | base64 --decode; echo)
    <!--NeedCopy-->
    

Erstellen eines geheimen Schlüsseltresors und Einrichten der Kubernetes-Authentifizierung auf dem Tresor-Server

Melden Sie sich beim Tresor-Server an und führen Sie die folgenden Schritte aus, um einen Key Vault-Schlüssel zu erstellen und die Kubernetes-Authentifizierung einzurichten.

  1. Überprüfen Sie die Vault-Richtliniendatei citrix-adc-kv-ro.hcl, und erstellen Sie eine schreibgeschützte Richtlinie citrix-adc-kv-ro in Vault.

    $ tee citrix-adc-kv-ro.hcl <<EOF 
    # If working with K/V v1
    path "secret/citrix-adc/*"
    {
        capabilities = ["read", "list"]
    }
    # If working with K/V v2
    path "secret/data/citrix-adc/*" 
    {
        capabilities = ["read", "list"]
    }
    EOF
    
    #  Create a policy named citrix-adc-kv-ro
    $  vault policy write citrix-adc-kv-ro citrix-adc-kv-ro.hcl
    
  2. Erstellen Sie ein KV-Geheimnis mit Citrix ADC-Anmeldeinformationen im Pfad secret/citrix-adc/.

    vault kv put secret/citrix-adc/credential   username='<ADC username>' \
    password='<ADC password>' \
    ttl='30m'
    
  3. Aktiviert die Kubernetes-Authentifizierung im Standardpfad (auth/kubernetes).

    # $ vault auth enable kubernetes
    
  4. Geben Sie an, wie mit dem Kubernetes-Cluster kommunizieren soll.

    $ vault write auth/kubernetes/config \
    token_reviewer_jwt="$SA_JWT_TOKEN" \
    kubernetes_host="https://<K8S_CLUSTER_URL>:<API_SERVER_PORT>" \
    kubernetes_ca_cert="$SA_CA_CRT"      
    
  5. Erstellen Sie eine Rolle, um das Kubernetes-Dienstkonto den Vault-Richtlinien und dem Standard-TTL-Token zuzuordnen. Diese Rolle autorisiert das Dienstkonto cic-k8s-role im Standard-Namespace und ordnet das Dienstkonto der Richtlinie citrix-adc-kv-ro zu.

    $ vault write auth/kubernetes/role/cic-vault-example\
    bound_service_account_names=cic-k8s-role \
    bound_service_account_namespaces=default \
    policies=citrix-adc-kv-ro \
    ttl=24h
    

    Hinweis:

    Die Autorisierung mit dem Kubernetes-Authentifizierungs-Backend ist rollenbasiert. Bevor ein Token für die Anmeldung verwendet wird, muss es als Teil einer Rolle konfiguriert werden.

Nutzen der automatischen Vault-Agent-Authentifizierung für den Citrix Ingress Controller

Führen Sie die folgenden Schritte aus, um die automatische Authentifizierung von Vault zu

  1. Lesen Sie die bereitgestellte Vault Agent-Konfigurationsdatei [vault-agent-config.hcl] (https://github.com/citrix/citrix-k8s-ingress-controller/blob/master/docs/how-to/examples-yamls/vault-agent-config.hcl).

        exit_after_auth = true
        pid_file = "/home/vault/pidfile"
    
        auto_auth {
            method "kubernetes" {
                mount_path = "auth/kubernetes"
                config = {
                    role = "cic-vault-example"
                }
            }
    
            sink "file" {
                config = {
                    path = "/home/vault/.vault-token"
                }
            }
        }
    

    Hinweis:

    Der Vault-Agent Auto-Auth ist für die Verwendung der Kubernetes-Authentifizierungsmethode konfiguriert, die im Pfad auth/kubernetesauf dem Tresor-Server aktiviert ist. Der Vault Agent verwendet die Rolle cic-vault-example zur Authentifizierung. Der Senkenblock gibt den Ort auf dem Datenträger an, an dem Token geschrieben werden sollen. Die Vault Auto-Auth Agent-Senke kann mehrfach konfiguriert werden, wenn Sie möchten, dass der Vault Agent das Token an mehreren Speicherorten platziert. In diesem Beispiel ist die Senke auf eingestellt /home/vault/.vault-token.

  2. Überprüfen Sie die Consul-template-config.hcl-Datei der Vorlage des Konsuls.

        vault {
            renew_token = false
            vault_agent_token_file = "/home/vault/.vault-token"
            retry {
                backoff = "1s"
            }
        }
    
        template {
            destination = "/etc/citrix/.env"
            contents = <<EOH
            NS_USER=
            NS_PASSWORD=
                
            EOH
        }
    

    This template reads secrets at the secret/citrix-adc/credential path and sets the user name and password values. If you are using KV store version 1, use the following template.

        template {
            destination = "/etc/citrix/.env"
            contents = <<EOH
            NS_USER=
            NS_PASSWORD=
                
            EOH
                }
    
  3. Erstellen Sie eine Kubernetes-Konfigurationszuordnung aus vault-agent-config.hcl und consul-template-config.hcl.

        kubectl create configmap example-vault-agent-config --from-file=./vault-agent-config.hcl --form-file=./consul-template-config.hcl
    
  4. Erstellen Sie einen Citrix Ingress Controller Ingress-Controller-Pod mit Vault und Consul-Vorlage als Init-Container citrix-k8s-ingress-controller-vault.yaml. Vault ruft das Token mithilfe der Kubernetes-Authentifizierungsmethode ab und leitet es an eine Konsulvorlage weiter, die die Datei .env auf einem gemeinsam genutzten Volume erstellt. Dieses Token wird vom Citrix Ingress Controller für die Authentifizierung mit Citrix ADC der Stufe 1 verwendet.

        kubectl apply citrix-k8s-ingress-controller-vault.yaml
    

    Die citrix-k8s-ingress-controller-vault.yaml Datei lautet wie folgt:

            apiVersion: v1
            kind: Pod
            metadata:
            annotations:
            name: cic-vault
            namespace: default
            spec:
            containers:
            - args:
                - --ingress-classes tier-1-vpx
                - --feature-node-watch true
                env:
                - name: NS_IP
                value: <Tier 1 ADC IP-ADDRESS>
                - name: EULA
                value: "yes"
                image: in-docker-reg.eng.citrite.net/cpx-dev/kumar-cic:latest
                imagePullPolicy: Always
                name: cic-k8s-ingress-controller
                volumeMounts:
                - mountPath: /etc/citrix
                name: shared-data
            initContainers:
            - args:
                - agent
                - -config=/etc/vault/vault-agent-config.hcl
                - -log-level=debug
                env:
                - name: VAULT_ADDR
                value: <VAULT URL>
                image: vault
                imagePullPolicy: Always
                name: vault-agent-auth
                volumeMounts:
                - mountPath: /etc/vault
                name: config
                - mountPath: /home/vault
                name: vault-token
            - args:
                - -config=/etc/consul-template/consul-template-config.hcl
                - -log-level=debug
                - -once
                env:
                - name: HOME
                value: /home/vault
                - name: VAULT_ADDR
                value: <VAULT_URL>
                image: hashicorp/consul-template:alpine
                imagePullPolicy: Always
                name: consul-template
                volumeMounts:
                - mountPath: /home/vault
                name: vault-token
                - mountPath: /etc/consul-template
                name: config
                - mountPath: /etc/citrix
                name: shared-data
            serviceAccountName: vault-auth
            volumes:
            - emptyDir:
                medium: Memory
                name: vault-token
            - configMap:
                defaultMode: 420
                items:
                - key: vault-agent-config.hcl
                    path: vault-agent-config.hcl
                - key: consul-template-config.hcl
            name: example-vault-agent-config
                name: config
            - emptyDir:
                medium: Memory
                name: shared-data        
    

Wenn die Konfiguration erfolgreich ist, holt der Tresor-Server ein Token und leitet es an einen Consul Template Container weiter. Die Vorlage Consul verwendet das Token, um Citrix ADC-Anmeldeinformationen zu lesen und als Umgebungsvariable in den Pfad zu schreiben /etc/citrix/.env. Der Citrix Ingress Controller verwendet diese Anmeldeinformationen für die Kommunikation mit dem Citrix ADC der Stufe 1.

Stellen Sie sicher, dass der Citrix Ingress Controller erfolgreich ausgeführt wird, indem Sie die vom Tresor-Server abgerufenen Anmeldeinformationen verwenden.

Verwenden von Citrix ADC-Anmeldeinformationen, die in einem Tresor-Server für den Citrix Ingress Controller gespeichert sind