Ingress Controller de Citrix ADC

Implementar el Citrix Ingress Controller de Citrix para Citrix ADC con particiones de administración

Citrix Ingress Controller se utiliza para configurar automáticamente uno o más Citrix ADC en función de la configuración de recursos de entrada. El dispositivo Citrix ADC de entrada (MPX o VPX) se puede particionar en entidades lógicas denominadas particiones de administración, donde cada partición se puede configurar y usar como un dispositivo Citrix ADC independiente. Para obtener más información, consulte Partición de administración. Citrix Ingress Controller también se puede implementar para configurar Citrix ADC con particiones de administración.

Para Citrix ADC con particiones de administración, debe implementar una sola instancia del controlador de entrada de Citrix para cada partición. Además, la partición debe estar asociada a un usuario de partición específico de la instancia del Citrix Ingress Controller.

Requisitos previos

Compruebe que:

  • Las particiones de administración se configuran en el dispositivo Citrix ADC. Para obtener instrucciones, consulte Configurar particiones administrativas.
  • Cree un usuario de partición específicamente para el Citrix Ingress Controller. Citrix Ingress Controller configura Citrix ADC mediante esta cuenta de usuario de partición. Asegúrese de no asociar este usuario de partición a otras particiones en el dispositivo Citrix ADC.

    Nota:

    Para casos de uso relacionados con SSL en la partición de administración, asegúrese de usar Citrix ADC versión 12.0 a 56.8 y superior.

Para implementar el Citrix Ingress Controller de Citrix para Citrix ADC con particiones de administración

  1. Descargue citrix-k8s-ingress-controller.yaml con el siguiente comando:

    wget  https://raw.githubusercontent.com/citrix/citrix-k8s-ingress-controller/master/deployment/baremetal/citrix-k8s-ingress-controller.yaml
    
  2. Modifique el archivo citrix-k8s-ingress-controller.yaml e introduzca los valores de las siguientes variables de entorno:

    Variable de entorno Obligatorio u opcional Descripción
    NS_IP Mandatory (Obligatorio) La dirección IP del dispositivo Citrix ADC. Para obtener más información, consulte Requisitos previos.
    NS_USER y NS_PASSWORD Mandatory (Obligatorio) El nombre de usuario y la contraseña del usuario de partición que ha creado para el Citrix Ingress Controller. Para obtener más información, consulte Requisitos previos.
    NS_VIP Mandatory (Obligatorio) El Citrix Ingress Controller utiliza la dirección IP proporcionada en esta variable de entorno para configurar una dirección IP virtual para el Citrix ADC que recibe el tráfico de entrada. Nota: NS_VIP actúa como alternativa cuando la anotación frontend-ip no se proporciona en Ingress yaml. Solo se admite para entrada.
    NS_SNIPS Opcional Especifica las direcciones SNIP en el dispositivo Citrix ADC o las direcciones SNIP en una partición de administración específica en el dispositivo Citrix ADC.
    NS_ENABLE_MONITORING Mandatory (Obligatorio) Defina el valor Yes para supervisar Citrix ADC. Nota: Asegúrese de inhabilitar la supervisión de Citrix ADC para Citrix ADC con particiones de administración. Defina el valor en No.
    EULA Mandatory (Obligatorio) El acuerdo de licencia de usuario final. Especifique el valor como Yes.
    Kubernetes_url Opcional La URL kube-apiserver que usa el Citrix Ingress Controller para registrar los eventos. Si no se especifica el valor, el Citrix Ingress Controller usa la dirección IP interna de kube-apiserver.
    LOGLEVEL Opcional Los niveles de registro para controlar los registros generados por el Citrix Ingress Controller. De forma predeterminada, el valor se establece en DEBUG. Los valores admitidos son: CRITICAL, ERROR, WARNING, INFO y DEBUG. Para obtener más información, consulte Niveles de registro
    NS_PROTOCOL y NS_PORT Opcional Define el protocolo y el puerto que debe utilizar el Citrix Ingress Controller para comunicarse con Citrix ADC. De forma predeterminada, el Citrix Ingress Controller usa HTTPS en el puerto 443. También puede usar HTTP en el puerto 80.
    clases-ingreso Opcional Si se utilizan varios equilibradores de carga de entrada para equilibrar la carga de diferentes recursos de entrada. Puede usar esta variable de entorno para especificar el Citrix Ingress Controller para configurar Citrix ADC asociado a una clase de entrada específica. Para obtener información sobre las clases Ingress, consulte Soporte de clases Ingress
  3. Una vez que actualice las variables de entorno, guarde el archivo YAML e impleméntelo con el siguiente comando:

    kubectl create -f citrix-k8s-ingress-controller.yaml
    
  4. Compruebe si el Citrix Ingress Controller se implementa correctamente mediante el siguiente comando:

    kubectl get pods --all-namespaces
    

Caso de uso: Cómo entregar de forma segura aplicaciones basadas en microservicios multiarrendatario mediante particiones de administración de Citrix ADC

Puede aislar el tráfico de entrada entre diferentes aplicaciones basadas en microservicios con la partición de administración de Citrix ADC mediante el Citrix Ingress Controller. La partición de administración de Citrix ADC permite el multiarrendamiento a nivel de software en una sola instancia de Citrix ADC. Cada partición tiene su propio plano de control y plano de red.

Puede implementar una instancia del controlador de entrada de Citrix en cada espacio de nombres de un clúster.

Por ejemplo, imagine que tiene dos espacios de nombres en un clúster de Kubernetes y desea aislar estos espacios de nombres entre sí en dos administradores diferentes. Puede usar la función de partición de administración para separar estos dos espacios de nombres. Cree el espacio de nombres 1 y el espacio de nombres 2 e implemente el controlador de entrada de Citrix por separado en ambos espacios de nombres.

Las instancias de Citrix Ingress Controller proporcionan instrucciones de configuración a las particiones Citrix ADC respectivas mediante la cuenta de usuario del sistema especificada en el manifiesto YAML.

Citrix ADC administra la carga de trabajo del clúster de Kubernetes mediante particiones administrativas

En este ejemplo, las aplicaciones de ejemplo de apache y libro de visitas se implementan en dos espacios de nombres diferentes (espacio de nombres 1 y espacio de nombres 2, respectivamente) en un clúster de Kubernetes. Tanto el equipo de aplicaciones apache como el de libros de visitas quieren administrar su carga de trabajo de forma independiente y no quieren compartir recursos. La partición de administración de Citrix ADC ayuda a lograr el multiarrendamiento y, en este ejemplo, se utilizan dos particiones (predeterminada, partición1) para administrar la carga de trabajo de ambas aplicaciones por separado.

Se aplican los siguientes requisitos previos:

  • Asegúrese de haber configurado particiones de administración en el dispositivo Citrix ADC. Para obtener instrucciones, consulte Configurar particiones administrativas.

  • Asegúrese de crear una cuenta de usuario de partición específica para el Citrix Ingress Controller. Citrix Ingress Controller configura Citrix ADC mediante esta cuenta de usuario de partición. Asegúrese de no asociar este usuario de partición a otras particiones en el dispositivo Citrix ADC.

Ejemplo

En el siguiente escenario de ejemplo, se muestra cómo implementar diferentes aplicaciones en diferentes espacios de nombres en un clúster de Kubernetes y cómo se puede aislar la solicitud de ADC mediante la partición de administración.

En este ejemplo, se implementan dos aplicaciones de muestra en dos espacios de nombres diferentes en un clúster de Kubernetes. En este ejemplo, se utiliza una partición predeterminada en Citrix ADC para la aplicación apache y la partición de administración p1 para la aplicación guestbook.

Crear espacios de nombres

Cree dos espacios de nombres ns1 y ns2 con estos comandos:

    kubectl create namespace ns1
    kubectl create namespace ns2

Configuraciones en el espacio de nombres ns1

  1. Implemente la aplicación apache en ns1.

    apiVersion: v1
    kind: Namespace
    metadata:
      name: ns1
    
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      labels:
        app: apache-ns1
      name: apache-ns1
      namespace: ns1
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: apache-ns1
      template:
        metadata:
          labels:
            app: apache-ns1
        spec:
          containers:
          - image: httpd
            name: httpd
    ---
    
    apiVersion: v1
    kind: Service
    metadata:
      creationTimestamp: null
      labels:
        app: apache-ns1
      name: apache-ns1
      namespace: ns1
    spec:
      ports:
      - port: 80
        protocol: TCP
        targetPort: 80
      selector:
        app: apache-ns1
    
  2. Implemente el Citrix Ingress Controller en ns1.

    Puede usar el archivo YAML para implementar el Citrix Ingress Controller o usar el gráfico Helm.

    Asegúrese de usar las credenciales de usuario que están enlazadas a la partición predeterminada.

    helm install cic-def-part-ns1 citrix/citrix-ingress-controller --set nsIP=<nsIP of ADC>,license.accept=yes,adcCredentialSecret=nslogin,ingressClass[0]=citrix-def-part-ns1 --namespace ns1
    
  3. Implemente el recurso Ingress.

    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
      name: ingress-apache-ns1
      namespace: ns1
      annotations:
        kubernetes.io/ingress.class: "citrix-def-part-ns1"
        ingress.citrix.com/frontend-ip: "< ADC VIP IP >"
    spec:
      rules:
      - host: apache-ns1.com
        http:
          paths:
          - backend:
              service:
                name: apache-ns1
                port:
                  number: 80
            pathType: Prefix
            path: /index.html
    
  4. Citrix Ingress Controller en ns1 configura las entidades ADC en la partición predeterminada.

Configuraciones en el espacio de nombres ns2

  1. Implemente la aplicación guestbook en ns2.

    apiVersion: v1
    kind: Namespace
    metadata:
      name: ns2
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: redis-master
      namespace: ns2
      labels:
        app: redis
        tier: backend
        role: master
    spec:
      ports:
      - port: 6379
        targetPort: 6379
      selector:
        app: redis
        tier: backend
        role: master
    ---
    apiVersion: apps/v1 #  for k8s versions before 1.9.0 use apps/v1beta2  and before 1.8.0 use extensions/v1beta1
    kind: Deployment
    metadata:
      name: redis-master
      namespace: ns2
    spec:
      selector:
        matchLabels:
          app: redis
          role: master
          tier: backend
      replicas: 1
      template:
        metadata:
          labels:
            app: redis
            role: master
            tier: backend
        spec:
          containers:
          - name: master
            image: k8s.gcr.io/redis:e2e  # or just image: redis
            resources:
              requests:
                cpu: 100m
                memory: 100Mi
            ports:
            - containerPort: 6379
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: redis-slave
      namespace: ns2
      labels:
        app: redis
        tier: backend
        role: slave
    spec:
      ports:
      - port: 6379
      selector:
        app: redis
        tier: backend
        role: slave
    ---
    apiVersion: apps/v1 #  for k8s versions before 1.9.0 use apps/v1beta2  and before 1.8.0 use extensions/v1beta1
    kind: Deployment
    metadata:
      name: redis-slave
      namespace: ns2
    spec:
      selector:
        matchLabels:
          app: redis
          role: slave
          tier: backend
      replicas: 2
      template:
        metadata:
          labels:
            app: redis
            role: slave
            tier: backend
        spec:
          containers:
          - name: slave
            image: gcr.io/google_samples/gb-redisslave:v1
            resources:
              requests:
                cpu: 100m
                memory: 100Mi
            env:
            - name: GET_HOSTS_FROM
              value: dns
              # If your cluster config does not include a dns service, then to
              # instead access an environment variable to find the master
              # service's host, comment out the 'value: dns' line above, and
              # uncomment the line below:
              # value: env
            ports:
            - containerPort: 6379
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: frontend
      namespace: ns2
      labels:
        app: guestbook
        tier: frontend
    spec:
      # if your cluster supports it, uncomment the following to automatically create
      # an external load-balanced IP for the frontend service.
      # type: LoadBalancer
      ports:
      - port: 80
      selector:
        app: guestbook
        tier: frontend
    ---
    apiVersion: apps/v1 #  for k8s versions before 1.9.0 use apps/v1beta2  and before 1.8.0 use extensions/v1beta1
    kind: Deployment
    metadata:
      name: frontend
      namespace: ns2
    spec:
      selector:
        matchLabels:
          app: guestbook
          tier: frontend
      replicas: 3
      template:
        metadata:
          labels:
            app: guestbook
            tier: frontend
        spec:
          containers:
          - name: php-redis
            image: gcr.io/google-samples/gb-frontend:v4
            resources:
              requests:
                cpu: 100m
                memory: 100Mi
            env:
            - name: GET_HOSTS_FROM
              value: dns
              # If your cluster config does not include a dns service, then to
              # instead access environment variables to find service host
              # info, comment out the 'value: dns' line above, and uncomment the
              # line below:
              # value: env
            ports:
            - containerPort: 80
    
  2. Implemente el Citrix Ingress Controller en el espacio de nombres ns2.

    Asegúrese de usar las credenciales de usuario que están enlazadas a la partición p1.

    helm install cic-adm-part-p1 citrix/citrix-ingress-controller --set nsIP=<nsIP of ADC>,nsSNIPS='[<SNIPs in partition p1>]',license.accept=yes,adcCredentialSecret=admin-part-user-p1,ingressClass[0]=citrix-adm-part-ns2 --namespace ns2
    
  3. Implemente la entrada para la aplicación guestbook.

    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
      annotations:
      kubernetes.io/ingress.class: citrix-adm-part-ns2
      ingress.citrix.com/frontend-ip: "<VIP in partition 1>"
      name: guestbook-ingress
      namespace: ns2
    spec:
      rules:
      - host: www.guestbook.com
        http:
          paths:
          - backend:
              service:
                name: frontend
                port:
                  number: 80
            path: /
            pathType: Prefix
    
  4. Citrix Ingress Controller en ns2 configura las entidades ADC en la partición p1.

Implementar el Citrix Ingress Controller de Citrix para Citrix ADC con particiones de administración