Ingress Controller de Citrix ADC

Usar las credenciales de Citrix ADC almacenadas en un servidor de Vault para el Citrix Ingress Controller

En la mayoría de las organizaciones, los dispositivos Citrix ADC Ingress de nivel 1 y los clústeres de Kubernetes son administrados por equipos separados. Por lo general, los administradores de red administran los dispositivos Citrix ADC Ingress de nivel 1, mientras que los desarrolladores administran los clústeres de Kubernetes. El Citrix Ingress Controller de Citrix requiere credenciales de Citrix ADC, como el nombre de usuario y la contraseña de Citrix ADC, para configurar Citrix ADC. Puede especificar las credenciales de Citrix ADC como parte de la especificación del Citrix Ingress Controller y almacenar las credenciales de ADC como secretos de Kubernetes. Sin embargo, también puede almacenar las credenciales de Citrix ADC en un servidor de Vault y pasar las credenciales al Citrix Ingress Controller para minimizar cualquier riesgo de seguridad. En este tema se proporciona información sobre cómo usar las credenciales de Citrix ADC almacenadas en un servidor de Vault para el Citrix Ingress Controller.

En el siguiente diagrama se explican los pasos para usar las credenciales de Citrix ADC que se almacenan en un servidor de Vault con el Citrix Ingress Controller.

vault-auto-authentication

Requisitos previos

Asegúrese de haber configurado un servidor de Vault y de haber habilitado el almacén secreto clave-valor (KV). Para obtener más información, consulte la documentación de Vault.

Usar credenciales de Citrix ADC desde un servidor de Vault para el Citrix Ingress Controller

Realice las siguientes tareas para usar las credenciales de Citrix ADC desde un servidor de Vault para el Citrix Ingress Controller.

  1. Crea una cuenta de servicio para la autenticación de Kubernetes.

  2. Crea un secreto de Key Vault y configura la autenticación de Kubernetes en el servidor de Vault.

  3. Aproveche la funcionalidad de autenticación automática de Vault para obtener las credenciales de Citrix ADC para el Citrix Ingress Controller.

Crear una cuenta de servicio para la autenticación de Kubernetes

Crea una cuenta de servicio para la autenticación de Kubernetes mediante los siguientes pasos:

  1. Crea una cuenta de servicio cic-k8s-role y proporciona a la cuenta de servicio los permisos necesarios para acceder a la API de Kubernetes TokenReview mediante el siguiente comando.

    $ 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. Establezca la variable de VAULT_SA_NAME entorno en el nombre de la cuenta de servicio que ya creó.

         export VAULT_SA_NAME=$(kubectl get sa cic-k8s-role -o jsonpath="{.secrets[*]['name']}")
    <!--NeedCopy-->
    
  3. Establece la variable de SA_JWT_TOKEN entorno en el JWT de la cuenta de servicio que usaste para acceder a la API TokenReview.

         export SA_JWT_TOKEN=$(kubectl get secret $VAULT_SA_NAME -o jsonpath="{.data.token}" | base64 --decode; echo)
    <!--NeedCopy-->
    
  4. Obtenga un certificado firmado por una CA de Kubernetes para comunicarse con la API de Kubernetes.

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

Crear un secreto de depósito de claves y configurar la autenticación de Kubernetes en el servidor de Vault

Inicie sesión en el servidor de Vault y lleve a cabo los siguientes pasos para crear un secreto de Key Vault y configurar la autenticación de Kubernetes.

  1. Revise el archivo de directivas de Vault de ejemplo citrix-adc-kv-ro.hcl y cree una directiva de solo lectura citrix-adc-kv-ro en 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. Cree un secreto KV con las credenciales de Citrix ADC en la secret/citrix-adc/ ruta.

    vault kv put secret/citrix-adc/credential   username='<ADC username>' \
    password='<ADC password>' \
    ttl='30m'
    
  3. Habilite la autenticación de Kubernetes en la ruta predeterminada (auth/kubernetes).

    # $ vault auth enable kubernetes
    
  4. Especifique cómo comunicarse con el clúster de Kubernetes.

    $ 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. Crea una función para asignar la cuenta de servicio de Kubernetes a las directivas de Vault y al TTL de token predeterminado. Esta función autoriza la cuenta de cic-k8s-role servicio en el espacio de nombres predeterminado y asigna la cuenta de servicio a la directiva citrix-adc-kv-ro.

    $ 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
    

    Nota:

    La autorización con el back-end de autenticación de Kubernetes se basa en roles. Antes de que se use un token para iniciar sesión, debe configurarse como parte de un rol.

Aproveche la autenticación automática del agente de Vault para el Citrix Ingress Controller

Realice los siguientes pasos para aprovechar la autenticación automática de Vault.

  1. Revise el archivo de configuración de Vault Agent proporcionado, [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"
                }
            }
        }
    

    Nota:

    El agente de Vault Auto-Auth está configurado para usar el método de autenticación de Kubernetes habilitado en la auth/kubernetes ruta del servidor de Vault. El agente de Vault usa la cic-vault-example función para autenticarse. El bloque sumidero especifica la ubicación en el disco en la que se escribirán los tokens. El Auto-Auth receptor de Vault Agent se puede configurar varias veces si quiere que Vault Agent coloque el token en varias ubicaciones. En este ejemplo, el lavabo se establece en /home/vault/.vault-token.

  2. Revisa el archivo consul-template-config.hcl de la plantilla Consul.

        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. Crea un mapa de configuración de Kubernetes desde vault-agent-config.hcl y consul-template-config.hcl.

        kubectl create configmap example-vault-agent-config --from-file=./vault-agent-config.hcl --form-file=./consul-template-config.hcl
    
  4. Cree un pod de Citrix Ingress Controller con una plantilla de Vault y consul como contenedor de inicio citrix-k8s-ingress-controller-vault.yaml. Vault obtiene el token mediante el método de autenticación de Kubernetes y lo pasa a una plantilla de cónsul que crea el archivo .env en el volumen compartido. El controlador de entrada de Citrix utiliza este token para la autenticación con Citrix ADC de nivel 1.

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

    El citrix-k8s-ingress-controller-vault.yaml archivo es el siguiente:

            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        
    

Si la configuración se realiza correctamente, el servidor de Vault obtiene un token y lo pasa a un contenedor de plantillas de Consul. La plantilla Consul utiliza el token para leer las credenciales de Citrix ADC y escribirlas como una variable de entorno en la ruta /etc/citrix/.env. El Citrix Ingress Controller usa estas credenciales para comunicarse con el Citrix ADC de nivel 1.

Compruebe que el Citrix Ingress Controller se ejecuta correctamente mediante las credenciales obtenidas del servidor de Vault.

Usar las credenciales de Citrix ADC almacenadas en un servidor de Vault para el Citrix Ingress Controller