Citrix Application Delivery Management

Instalar el agente de Citrix ADM en Amazon Web Services (AWS)

El agente Citrix Application Delivery Management (Citrix ADM) funciona como intermediario entre Citrix ADM y las instancias detectadas en el centro de datos o en la nube.

Requisitos previos

Para iniciar una AMI de agente Citrix ADM dentro de una nube privada virtual (VPC) de Amazon Web Services (AWS) mediante la interfaz gráfica de usuario de Amazon, necesita:

  • Una cuenta de AWS

  • Una nube privada virtual (VPC) de AWS

  • Una cuenta de IAM

Nota

  • Antes de aprovisionar una máquina virtual de agente ADM, Citrix recomienda crear grupos de seguridad, red privada virtual, par de claves, subred y otras entidades. Por lo tanto, la información de red está disponible durante el aprovisionamiento.

  • Para que un agente Citrix ADM se comunique con Citrix ADM y las instancias de Citrix ADC, asegúrese de que los puertos recomendados estén abiertos. Para obtener información detallada sobre los requisitos de puerto para un agente Citrix ADM, consulte Puertos.

Para instalar el agente Citrix ADM en AWS:

  1. Inicie sesión en el Mercado de AWS mediante sus credenciales de AWS.

  2. En el campo de búsqueda, escriba Citrix ADM Agent para buscar la AMI del agente Citrix ADM y haga clic en Ir.

  3. En la página de resultados de búsqueda, haga clic en la AMI del agente externo de ADM en la lista disponible.

  4. En la página AMI del agente externo de ADM, haga clic en Continuar para suscribirse.

    Agente externo de ADM

  5. Una vez que la suscripción se haya realizado correctamente, haga clic en Continuar con Configuración.

    Continuar la configuración

  6. En la página Configurar este software :

    1. Seleccione la AMI en la lista de opciones de gestión logística.

    2. Seleccione la versión más reciente del agente de Citrix ADM en la lista Versión de software.

    3. Seleccione su región en la lista Región.

    4. Haga clic en Continuar para iniciar

      Continuar con el lanzamiento

  7. En la página Iniciar este software, tiene dos opciones para registrar el agente Citrix ADM:

    1. Lanzamiento desde el sitio web

    2. Lanzamiento con EC2

      Lanzamiento con EC2

Lanzamiento desde un sitio web

Para iniciar desde un sitio web, seleccione:

  1. Un tipo de instancia EC2 de la lista Tipo de instancia EC2

  2. Una VPC de la lista Configuración de VPC. Haga clic en Crear una VPC en EC2 para crear una VPC para su software.

  3. Una subred de la lista Configuración de subred. Haga clic en Crear una subred en EC2 para crear una subred después de seleccionar la VPC.

  4. Un grupo de seguridad para el firewall de la lista Configuración del grupo de seguridad. Haz clic en Crear nuevo basado en la configuración del vendedor para crear un grupo de seguridad.

  5. Un par de claves para garantizar la seguridad de acceso desde la lista Configuración de pares de claves. Haga clic en Crear un par de claves en EC2 para crear un par de claves para el software.

  6. Haga clic en Iniciar

    Iniciar un sitio web

  7. El lanzamiento desde un sitio web es correcto.

    El lanzamiento desde un sitio web es correcto

    Nota

    El proceso de implementación puede tardar entre 10 y 15 minutos aproximadamente. Una vez completada correctamente la implementación, puede ver la máquina virtual del agente Citrix ADM en su cuenta de AWS.

  8. Una vez implementado el agente, asigne un nombre al agente Citrix ADM.

  9. Una vez que el agente esté en funcionamiento, asigne una dirección IP elástica para su agente Citrix ADM.

    Nota

    La dirección IP elástica permite al agente Citrix ADM comunicarse con Citrix ADM. Sin embargo, es posible que no se requiera una dirección IP elástica si ha configurado NAT Gateway para enrutar el tráfico a Internet.

  10. Con un cliente SSH, inicie sesión en su agente Citrix ADM utilizando la dirección IP pública.

    Nota

    Puede iniciar sesión en Citrix ADM Agent mediante una de las siguientes formas:

    • Utilice nsrecover como nombre de usuario y como ID de instancia de AWS como contraseña.

    • Utilice nsroot como nombre de usuario y un par de claves válido como contraseña.

  11. Introduzca el siguiente comando para invocar la pantalla de despliegue: deployment_type.py

  12. Introduzca la URL de servicio y el código de activación que ha copiado y guardado desde la página Configurar agentes en Citrix ADM, como se indica en Introducción. El agente utiliza la URL del servicio para localizar el servicio y el código de activación para registrarse en el servicio.

    Implementación del servicio ADM

Una vez que el registro del agente se realiza correctamente, el agente se reinicia para completar el proceso de instalación.

Después de reiniciar el agente, acceda a Citrix ADM y, en la página Configurar agente, en Agentes descubiertos, compruebe el estado del agente.

Lanzamiento con EC2

Para iniciar con EC2, seleccione Iniciar a través de EC2 en la lista Elegir acción y, a continuación, haga clic en Iniciar.

  1. En la página Elegir un Tipo de Instancia, seleccione la instancia y haga clic en Siguiente: Configurar Detalles de Instancia.

    Configurar los detalles de la instancia

  2. En la página Configurar Detalles de Instancia, especifique los parámetros necesarios.

    En la sección Detalles avanzados, puede habilitar un agente de contacto cero especificando detalles de autenticación o una secuencia de comandos en el campo Datos del usuario.

    • Detalles de autenticación : especifique la URL del servicio y el código de activación que copió de la página Configurar agentes de Citrix ADM como se indica en Introducción. Introduzca los detalles en el siguiente formato.

       registeragent -serviceurl <apigatewayurl> -activationcode <activationcodevalue>
       <!--NeedCopy-->
      

      El agente utiliza esta información para registrarse automáticamente con el servicio ADM durante el arranque.

    • Script : especifique un script de registro automático del agente como datos de usuario. A continuación se muestra una secuencia de comandos de ejemplo:

       #!/var/python/bin/python2.7
       import os
       import requests
       import json
       import time
       import re
       import logging
       import logging.handlers
       import boto3
      
       '''
       Overview of the Script:
       The script helps to register an ADM agent with ADM. Pass it in userdata to make ADM agent in AWS to autoregister on bootup. The workflow is as follows
       1)  Fetch the ADM service API credentials (ID and secret) from AWS secret store (NOTE: you have to assign IAM role to the ADM Agent that will give permission to fetch secrets from AWS secret store)
       2)  Login to ADM service with credentials fetched in step 1
       3)  Call ADM service to fetch credentials (serviceURL and token) for agent registration
       4)  Calls registration by using the credentials fetched in step 3
       '''
      
       '''
       These are the placeholders which you need to replace according to your setup configurations
       aws_secret_id: Id of the AWS secret where you have stored ADM Credentials
       The secrets value should be in the following json format
       { "adm_user_id_key": "YOUR_ID", " adm_user_secret_key": "YOUR_SECRET"}
       '''
      
       aws_secret_id = "<AWS_secret_id>"
       adm_ip_or_hostname = "<YOUR_ADM_POP>.adm.cloud.com"
      
       '''
       Set up a specific logger with your desired output level and log file name
       '''
       log_file_name_local = os.path.basename(\_\_file\_\_)
       LOG_FILENAME = '/var/log/' + 'bootstrap' + '.log'
       LOG_MAX_BYTE = 50\*1024\*1024
       LOG_BACKUP_COUNT = 20
      
       logger = logging.getLogger(\_\_name\_\_)
       logger.setLevel(logging.DEBUG)
       logger_handler = logging.handlers.RotatingFileHandler(LOG_FILENAME, maxBytes=LOG_MAX_BYTE, backupCount=LOG_BACKUP_COUNT)
       logger_fortmater = logging.Formatter(fmt='%(asctime)-2s:%(funcName)30s:%(lineno)4d: [%(levelname)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
       logger_handler.setFormatter(logger_fortmater)
       logger.addHandler(logger_handler)
      
       class APIHandlerException(Exception):
           def \_\_init\_\_(self, error_code, message):
               self.error_code = error_code
               self.message = message
      
           def \_\_str\_\_(self):
               return self.message + ". Error code '" + str(self.error_code) + "'"
      
       def parse_response(response, url, print_response=True):
           if not response.ok:
               if "reboot" in url:
                   logger.debug('No response for url: reboot')
                   resp = {"errorcode": "500", "message": "Error while reading response."}
                   return resp
      
               if print_response:
                   logger.debug('Response text for %s is %s' % (url, response.text))
      
               response = json.loads(response.text)
               logger.debug("ErrorCode - " + str(response['errorcode']) + ". Message -" + str(response['message']))
               raise APIHandlerException(response['errorcode'], str(response['message']))
           elif response.text:
               if print_response:
                   logger.debug('Response text for %s is %s' % (url, response.text))
      
               result = json.loads(response.text)
               if 'errorcode' in result and result['errorcode'] > 0:
                   raise APIHandlerException(result['errorcode'], str(result['message']))
               return result
      
       def _request(method, url, data=None, headers=None, retry=3, print_response=True):
           try:
               response = requests.request(method, url, data=data, headers=headers)
               result = parse_response(response, url, print_response=print_response)
               return result
           except [requests.exceptions.ConnectionError, requests.exceptions.ConnectTimeout]:
               if retry > 0:
                   return _request(method, url, data, headers, retry-1, print_response=print_response)
               else:
                   raise APIHandlerException(503, 'ConnectionError')
           except requests.exceptions.RequestException as e:
               logger.debug(str(e))
               raise APIHandlerException(500, str(e))
           except APIHandlerException as e:
               logger.debug("URL: %s, Error: %s, Message: %s" % (url, e.error_code, e.message))
               raise e
           except Exception as e:
               raise APIHandlerException(500, str(e))
      
       try:
           '''Get the AWS Region'''
           client = boto3.client('s3')
           my_region = client.meta.region_name
           logger.debug("The rgion is %s" % (my_region))
      
           '''Creating a Boto cleint session'''
           session = boto3.session.Session()
           client = session.client(
               service_name='secretsmanager',
               region_name=my_region
           )
      
           '''Getting the values stored in the secret with id: <aws_secret_id>'''
           get_id_value_response = client.get_secret_value(
               SecretId = aws_secret_id
           )
           adm_user_id = json.loads(get_id_value_response["SecretString"])["adm_user_id_key"]
           adm_user_secret = json.loads(get_id_value_response["SecretString"])["adm_user_secret_key"]
      
       except Exception as e:
           logger.debug("Fetching of ADM credentials from AWS secret failed with error: %s" % (str(e)))
           raise e
      
       '''
       Initializing common ADM API handlers
       '''
       mas_common_headers = {
           'Content-Type': "application/json",
           'Accept-type': "application/json",
           'Connection': "keep-alive",
           'isCloud': "true"
       }
      
       '''
       API to login to the ADM and fetch the Session ID and Tenant ID
       '''
       url = "https://" + str(adm_ip_or_hostname) + "/nitro/v1/config/login"
       payload = 'object={"login":{"ID":"' + adm_user_id + '","Secret":"' + adm_user_secret + '"}}'
       try:
           response = _request("POST", url, data=payload, headers=mas_common_headers)
           sessionid = response["login"][0]["sessionid"]
           tenant_id = response["login"][0]["tenant_name"]
       except Exception as e:
           logger.debug("Login call to the ADM failed with error: %s" % (str(e)))
           raise e
      
       '''
       API to fetch the service URL and Token to be used for registering the agent with the ADM
       '''
       mas_common_headers['Cookie'] = 'SESSID=' + str(sessionid)
       url = "https://" + str(adm_ip_or_hostname) + "/nitro/v1/config/trust_preauthtoken/" + tenant_id +"?customer="+ tenant_id
       logger.debug("Fetching Service URL and Token.")
       try:
           response = _request("GET", url, data=None, headers=mas_common_headers)
           service_name  = response["trust_preauthtoken"][0]["service_name"]
           token = response["trust_preauthtoken"][0]["token"]
           api_gateway_url = response["trust_preauthtoken"][0]["api_gateway_url"]
       except Exception as e:
           logger.debug("Fetching of the Service URL Passed with error. %s" % (str(e)))
           raise e
      
       '''
       Running the register agent command using the values we retrieved earlier
       '''
       try:
           registeragent_command = "registeragent -serviceurl "+api_gateway_url+" -activationcode "+service_name+";"+token
           file_run_command = "/var/python/bin/python2.7 /mps/register_agent_cloud.py "+registeragent_command
           logger.debug("Executing registeragent command: %s" % (file_run_command))
           os.system(file_run_command)
       except Exception as e:
           logger.debug("Agent Registeration failed with error: %s" % (str(e)))
               raise e
       <!--NeedCopy-->
      

      Este script obtiene los detalles de autenticación del administrador de secretos de AWS y ejecuta el deployment.py script para registrar el agente en el servicio ADM.

    Configurar los detalles de la instancia

    Nota

    Aunque puede asignar automáticamente direcciones IP públicas, también puede asignar direcciones IP elásticas. La asignación de una dirección IP elástica es necesaria cuando la puerta de enlace NAT no está configurada.

    Si la dirección IP elástica no está configurada en este paso, aún puede hacerlo en la consola EC2. Puede crear una nueva dirección IP elástica y asociarla con el Agente de ADM mediante el ID de instancia o ENI-ID.

    Haga clic en Agregar almacenamiento.

  3. En la página Agregar almacenamiento, configure la configuración del dispositivo de almacenamiento para la instancia y haga clic en Siguiente: Agregar etiquetas.

    Agregar etiquetas

  4. En la página Agregar etiquetas, defina la etiqueta de la instancia y haga clic en Siguiente: Configurar grupo de seguridad.

    Configurar grupo de seguridad

  5. En la página Configurar grupo de seguridad, agregue reglas para permitir tráfico específico a la instancia y haga clic en Revisar y lanzar.

    Revisar y lanzar

  6. En la página Revisar Inicio de Instancia, revise la configuración de la instancia y haga clic en Iniciar.

  7. En el cuadro de diálogo Seleccionar un par de claves existente o crear un par de claves nuevo, cree un par de claves. También puede seleccionar entre los pares de claves existentes.

    Acepte el acuse de recibo y haga clic en Iniciar instancias.

    Iniciar instancias

El proceso de implementación puede tardar entre 10 y 15 minutos aproximadamente. Una vez completada correctamente la implementación, puede ver la máquina virtual del agente Citrix ADM en su cuenta de AWS.

Instalar el agente de Citrix ADM en Amazon Web Services (AWS)