Citrix Application Delivery Management-Service

Installieren Sie den Citrix ADM Agenten auf Amazon Web Services (AWS)

Der Citrix Application Delivery Management (Citrix ADM) -Agent arbeitet als Vermittler zwischen Citrix ADM und den erkannten Instanzen im Rechenzentrum oder in der Cloud.

Voraussetzungen

Um ein Citrix ADM Agent-AMI innerhalb einer Amazon Web Services (AWS) Virtual Private Cloud (VPC) über die Amazon GUI zu starten, benötigen Sie:

  • Ein AWS-Konto

  • Eine virtuelle private AWS-Cloud (VPC)

  • Ein IAM-Konto

Hinweis

  • Bevor Sie eine virtuelle Maschine für ADM-Agenten bereitstellen, empfiehlt Citrix, Sicherheitsgruppe, virtuelles privates Netzwerk, Schlüsselpaar, Subnetz und andere Entitäten zu erstellen. Daher stehen die Netzwerkinformationen während der Provisioning zur Verfügung.

  • Damit ein Citrix ADM-Agent mit dem Citrix ADM und den Citrix ADC-Instanzen kommuniziert, stellen Sie sicher, dass die empfohlenen Ports geöffnet sind. Ausführliche Informationen zu den Portanforderungen für einen Citrix ADM -Agent finden Sie unter Ports.

So installieren Sie den Citrix ADM Agent in AWS:

  1. MeldenAWS-MarktplatzSie sich mit Ihren AWS-Anmeldeinformationen am an.

  2. Geben Sie im Suchfeld Citrix ADM Agent ein, um nach dem Citrix ADM-Agent-AMI zu suchen, und klicken Sie auf Los.

  3. Klicken Sie auf der Suchergebnisseite in der verfügbaren Liste auf das ADM External Agent AMI.

  4. Klicken Sie auf der Seite ADM External Agent AMI auf Weiter zu Abonnieren.

    Externer ADM Agent

  5. Nachdem das Abonnement erfolgreich ist, klicken Sie auf Weiter zur Konfiguration.

    Konfiguration fortsetzen

  6. Auf der Seite Diese Software konfigurieren:

    1. Wählen Sie das AMI aus der Fulfillment-Optionsliste aus.

    2. Wählen Sie die neueste Version des Citrix ADM Agenten aus der Liste Softwareversion aus.

    3. Wählen Sie Ihre Region aus der Liste Region aus.

    4. Klicken Sie auf Weiter, um zu starten

      Weiter zum Start

  7. Auf der Seite Diese Software starten haben Sie zwei Möglichkeiten, den Citrix ADM Agent zu registrieren:

    1. Start von der Website

    2. Start mit EC2

      Start mit EC2

Starten von einer Website

Um von einer Website aus zu starten, wählen Sie:

  1. Ein EC2-Instanz-Typ aus der Liste EC2-Instanz-Typ

  2. Eine VPC aus der Liste VPC-Einstellungen. Klicken Sie auf Erstellen einer VPC in EC2, um eine VPC für Ihre Software zu erstellen.

  3. Ein Subnetz aus der Liste Subnetzeinstellungen. Klicken Sie auf Subnetz in EC2 erstellen, um ein Subnetz zu erstellen, nachdem Sie die VPC ausgewählt haben.

  4. Eine Sicherheitsgruppe für die Firewall aus der Liste Sicherheitsgruppeneinstellungen. Klicken Sie auf Neue basierend auf Verkäufereinstellungen erstellen, um eine Sicherheitsgruppe zu erstellen.

  5. Ein Schlüsselpaar, um die Zugriffssicherheit aus der Liste Schlüsselpaar-Einstellungen zu gewährleisten. Klicken Sie in EC2 auf Schlüsselpaar erstellen, um ein Schlüsselpaar für Ihre Software zu erstellen.

  6. Klicken Sie auf Start

    Starten einer Website

  7. Der Start von einer Website ist erfolgreich.

    Start von einer Website ist erfolgreich

    Hinweis

    Der Bereitstellungsprozess kann etwa 10 bis 15 Minuten dauern. Nachdem die Bereitstellung erfolgreich abgeschlossen wurde, können Sie Ihre virtuelle Citrix ADM Agent-Maschine in Ihrem AWS-Konto anzeigen.

  8. Nachdem der Agent bereitgestellt wurde, weisen Sie Ihrem Citrix ADM Agent einen Namen zu.

  9. Nachdem der Agent ausgeführt wurde, weisen Sie dem Citrix ADM Agent eine elastische IP-Adresse zu.

    Hinweis

    Mit der Elastic IP-Adresse kann Citrix ADM Agent mit Citrix ADM kommunizieren. Eine elastische IP-Adresse ist jedoch möglicherweise nicht erforderlich, wenn Sie NAT-Gateway so konfiguriert haben, dass der Datenverkehr an das Internet weitergeleitet wird.

  10. Melden Sie sich mit einem SSH-Client an Ihrem Citrix ADM Agent mit der öffentlichen IP-Adresse an.

    Hinweis:

    Sie können sich mit einer der folgenden Methoden am Citrix ADM Agent anmelden:

    • Verwenden Sie nsrecoverals Benutzername und AWS-Instanz-ID als Kennwort.

    • Verwenden Sie nsrootals Benutzername und ein gültiges Schlüsselpaar als Kennwort.

  11. Geben Sie den folgenden Befehl ein, um den Bereitstellungsbildschirm aufzurufen: deployment_type.py

  12. Geben Sie die Service-URL und den Aktivierungscode ein, den Sie kopiert und auf der Seite Agents einrichten in Citrix ADM gespeichert haben Erste Schritte. Der Agent verwendet die Dienst-URL, um den Dienst zu finden, und den Aktivierungscode, um sich beim Dienst zu registrieren.

    Bereitstellung von ADM-Services

Nach erfolgreicher Agentenregistrierung wird der Agent neu gestartet, um den Installationsvorgang abzuschließen.

Nachdem der Agent neu gestartet wurde, greifen Sie auf Citrix ADM zu und überprüfen Sie auf der Seite Agent einrichten unter Ermittelte Agents den Status des Agents.

Start mit EC2

Um mit EC2 zu starten, wählen Sie Start über EC2 aus der Liste Aktion auswählen aus, und klicken Sie dann auf Starten.

  1. Wählen Sie auf der Seite Choose an Instanz Type die Instanz aus und klicken Sie auf Next: Configure Instanz Details.

    Instanzdetails konfigurieren

  2. Geben Sie auf der Seite Configure Instanz Details die erforderlichen Parameter an.

    Im Abschnitt Erweiterte Details können Sie einen Zero-Touch-Agenten aktivieren, indem Sie Authentifizierungsdetails oder ein Skript im Feld Benutzerdaten angeben.

    • Details zur Authentifizierung — Geben Sie die Dienst-URL und den Aktivierungscode an, den Sie von der Seite “ Agenten einrichten “ in Citrix ADM kopiert haben, wie in beschrieben Erste Schritte. Geben Sie die Details im folgenden Format ein.

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

      Der Agent verwendet diese Informationen, um sich beim Hochfahren automatisch beim ADM-Dienst zu registrieren.

    • Skript - Geben Sie ein Skript zur automatischen Registrierung des Agenten als Benutzerdaten an. Das Folgende ist ein Beispielskript:

       #!/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-->
      

      Dieses Skript ruft die Authentifizierungsdetails vom AWS Secrets Manager ab und führt das deployment.py Skript aus, um den Agenten beim ADM-Service zu registrieren.

    Instanzdetails konfigurieren

    Hinweis

    Sie können öffentliche IP-Adresse zwar automatisch zuweisen, aber Sie können auch elastische IP-Adresse zuweisen. Das Zuweisen einer elastischen IP-Adresse ist erforderlich, wenn NAT-Gateway nicht konfiguriert ist.

    Wenn die Elastic IP-Adresse in diesem Schritt nicht festgelegt ist, können Sie dies weiterhin auf der EC2-Konsole tun. Sie können eine neue elastische IP-Adresse erstellen und diese mithilfe der Instanz-ID oder ENI-ID dem ADM-Agenten zuordnen.

    Klicken Sie auf “ Speicher hinzufügen

  3. Konfigurieren Sie auf der Seite “ Speicher hinzufügen “ die Einstellungen des Speichergeräts für die Instanz und klicken Sie auf Weiter: Tags hinzufügen.

    Tags hinzufügen

  4. Definieren Sie auf der Seite Add Tags das Tag für die Instanz und klicken Sie auf Weiter: Security Group konfigurieren.

    Konfigurieren der Sicherheitsgruppe

  5. Fügen Sie auf der Seite Configure Security Group Regeln hinzu, um bestimmten Traffic zu Ihrer Instanz zu erlauben, und klicken Sie auf Review and Launch

    Überprüfen und starten

  6. Überprüfen Sie auf der Seite Review Instanz Launch die Instanz-Einstellungen und klicken Sie auf Starten.

  7. Erstellen Sie im Dialogfeld Wählen Sie ein vorhandenes Schlüsselpaar aus oder erstellen Sie ein neues Schlüsselpaar ein Schlüsselpaar. Sie können auch aus den vorhandenen Schlüsselpaaren wählen.

    Akzeptieren Sie die Bestätigung und klicken Sie auf Launch Instanzen.

    Instanzen starten

Der Bereitstellungsprozess kann etwa 10 bis 15 Minuten dauern. Nachdem die Bereitstellung erfolgreich abgeschlossen wurde, können Sie Ihre virtuelle Citrix ADM Agent-Maschine in Ihrem AWS-Konto anzeigen.

Installieren Sie den Citrix ADM Agenten auf Amazon Web Services (AWS)