Citrix Application Delivery Management-Service

Installieren des Citrix ADM-Agenten in der Microsoft Azure-Cloud

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

Um den Citrix ADM Agent in der Microsoft Azure-Cloud zu installieren, müssen Sie eine Instanz des Agenten im virtuellen Netzwerk erstellen. Rufen Sie das Citrix ADM Agent-Image vom Azure Marketplace ab, und verwenden Sie dann das Azure Resource Manager-Portal, um den Agenten zu erstellen.

Bevor Sie mit dem Erstellen der Citrix ADM Agent-Instanz beginnen, stellen Sie sicher, dass Sie ein virtuelles Netzwerk mit den erforderlichen Subnetzen erstellt haben, in denen sich die Instanz befindet. Sie können während des VM-Provisionings virtuelle Netzwerke erstellen, jedoch ohne die Flexibilität, verschiedene Subnetze einzurichten. Hinweise zum Erstellen virtueller Netzwerke finden Sie unter http://azure.microsoft.com/en-us/documentation/articles/create-virtual-network.

Konfigurieren Sie die DNS-Server- und VPN-Konnektivität, die es einer virtuellen Maschine ermöglicht, auf Internetressourcen zuzugreifen.

Voraussetzungen

Stellen Sie sicher, dass Sie Folgendes haben:

  • Ein Microsoft Azure-Benutzerkonto
  • Zugriff auf Microsoft Azure Resource Manager

Hinweis

  • Citrix empfiehlt, vor der Bereitstellung der virtuellen Citrix ADM Agent-Maschine Ressourcengruppe, Netzwerksicherheitsgruppe, virtuelles Netzwerk und andere Entitäten zu erstellen, damit die Netzwerkinformationen während der Provisioning verfügbar sind.
  • Damit der Citrix ADM-Agent mit Citrix ADM und den Citrix ADC-Instanzen kommunizieren kann, stellen Sie sicher, dass die empfohlenen Ports geöffnet sind. Vollständige Einzelheiten zu den Port-Anforderungen für den Citrix ADM Agent finden Sie unter Ports.

So installieren Sie den Citrix ADM Agent in Microsoft Azure Cloud:

  1. Melden Sie sich mit Ihren Microsoft Azure-Anmeldeinformationen am Azure-Portal (https://portal.azure.com) an.

  2. Klicken Sie auf +Eine Ressource erstellen.

  3. Geben Citrix ADM Agent Sie die Suchleiste ein und wählen Sie Citrix ADM Service Agentaus.

    Azure-Netzwerkbereich

  4. Klicken Sie auf Erstellen.

    Erstellen eines Ressourcenmanagers

  5. Geben Sie im Bereich Virtuelle Maschine erstellen in jedem Abschnitt die erforderlichen Werte an, um eine virtuelle Maschine zu erstellen.

    Grundlagen:

    Geben Sie auf dieser Registerkarte Projektdetails, Instanzdetailsund Administratorkontoan.

    Erstellen einer virtuellen Maschine

    • Ressourcengruppe — Wählen Sie die von Ihnen erstellte Ressourcengruppe aus der Dropdownliste aus.

      Hinweis

      Sie können zu diesem Zeitpunkt eine Ressourcengruppe erstellen, aber Citrix empfiehlt, dass Sie eine Ressourcengruppe aus Ressourcengruppen im Azure Resource Manager erstellen und dann die Gruppe aus der Dropdown-Liste auswählen.

    • Name der virtuellen Maschine — Geben Sie einen Namen für die Citrix ADM Agent-Instanz an.

    • Region - Wählen Sie die Region aus, in der Sie einen Agenten ausbringen möchten.

    • Verfügbarkeitsoptionen — Wählen Sie den Verfügbarkeitssatz aus der Liste aus.

    • Bild - In diesem Feld wird das bereits ausgewählte Agenten-Image angezeigt. Wenn Sie zu einem anderen Agenten-Image wechseln möchten, wählen Sie das gewünschte Bild aus der Liste aus.

    • Größe - Geben Sie den Typ und die Größe des virtuellen Laufwerks für die Bereitstellung Ihres Citrix ADM-Agenten an.

      Wählen Sie den Typ Unterstützte virtuelle Laufwerke (HDD oder SSD) aus der Liste aus.

    • Authentifizierungstyp — Wählen Sie Kennwort aus.

    • Benutzername und Kennwort — Geben Sie einen Benutzernamen und ein Kennwort an, um auf die Ressourcen in der von Ihnen erstellten Ressourcengruppe zuzugreifen.

    Datenträger:

    Auf dieser Registerkarte geben Sie Datenträgeroptionen und Datendatenträgeran.

    Informationen zu Datenträgern angeben

    • Betriebssystemdatenträgertyp - Wählen Sie den Typ des virtuellen Laufwerks (HDD oder SSD) aus.

    Vernetzung:

    Geben Sie die erforderlichen Netzwerkdetails an:

    Festlegen von Netzwerken

    • Virtuelles Netzwerk — Wählen Sie das virtuelle Netzwerk aus.
    • Subnet — Legen Sie die Subnetzadresse fest.
    • Öffentliche IP-Adresse — Wählen Sie die IP-Adresse aus.
    • Netzwerksicherheitsgruppe — Wählen Sie die Sicherheitsgruppe aus, die Sie erstellt haben.
    • Eingehende Ports auswählen - Wenn Sie öffentliche eingehende Ports zulassen, stellen Sie sicher, dass die eingehenden und ausgehenden Regeln in der Sicherheitsgruppe konfiguriert sind. Wählen Sie dann die eingehenden Ports aus der Liste aus. Weitere Einzelheiten finden Sie unter Voraussetzungen.

    Geschäftsführung:

    Geben Sie Azure Security Center, Überwachungund Identitätan.

    Verwaltung angeben

    Fortgeschritten:

    Optional geben Sie Erweiterungen, benutzerdefinierte Datenund Proximity-Platzierungsgruppean.

    Spezifizieren Sie Adv

    In Custom Datakönnen Sie ein Skript zur automatischen Registrierung für Agenten angeben, um den Agenten beim ADM-Dienst zu registrieren. Es folgt ein Beispielskript, das das deployment.py Skript ausführt und den Agenten registriert:

    ```python
    #!/var/python/bin/python2.7
    import os
    import requests
    import json
    import time
    import re
    import logging
    import logging.handlers
    import boto3
    
    '''
    Das Skript im Überblick:
    Das Skript hilft bei der Registrierung eines ADM-Agenten bei ADM. Übergeben Sie es in Benutzerdaten, damit sich der ADM-Agent in AWS beim Booten automatisch registriert. Der Workflow ist wie folgt
    1)  Holen Sie sich die ADM-Service-API-Anmeldeinformationen (ID und Secret) aus dem AWS Secret Store (HINWEIS: Sie müssen dem ADM Agent die IAM-Rolle zuweisen, die die Berechtigung zum Abrufen von Secrets aus dem AWS-Geheimspeicher erteilt)
    2)  Melden Sie sich bei ADM-Dienst mit Anmeldedaten an, die in Schritt 1 abgerufen wurden
    3)  Rufen Sie ADM-Dienst auf, um Anmeldeinformationen (serviceURL und Token) für die Agentenregistrierung abzurufen
    4)  Ruft die Registrierung an, indem die in Schritt 3 geholten Anmeldedaten verwendet werden
    '''
    
    '''
    Dies sind die Platzhalter, die Sie entsprechend Ihren Setup-Konfigurationen ersetzen müssen
    aws_secret_id: ID des AWS-Geheimnisses, in dem Sie ADM-Anmeldeinformationen gespeichert haben
    Der Secrets-Wert sollte im folgenden JSON-Format vorliegen
    { "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"
    
    '''
    Richten Sie einen bestimmten Logger mit Ihrem gewünschten Ausgabe-Level und Log-Dateinamen ein
    '''
    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
    
    '''
    Initialisieren von gängigen ADM API-Handlern
    '''
    mas_common_headers = {
        'Content-Type': "application/json",
        'Accept-type': "application/json",
        'Connection': "keep-alive",
        'isCloud': "true"
    }
    
    '''
    API zum Anmelden beim ADM und zum Abrufen der Session-ID und der Mandanten-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 zum Abrufen der Service-URL und des Token, die für die Registrierung des Agenten beim ADM verwendet werden sollen
    '''
    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
    
    '''
    Ausführen des Befehls register agent mit den Werten, die wir zuvor abgerufen haben
    '''
    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--> ```
    

    Wenn Sie dieses Skript für die automatische Registrierung angeben, überspringen Sie Schritt 7 und 8.

    Tags:

    Geben Sie das Schlüssel-Wert-Paar für die ADM-Agent-Tags ein. Ein Tag besteht aus einem Schlüssel-Wert-Paar, das zwischen Groß- und Kleinschreibung unterschieden wird. Mit diesen Tags können Sie den Agenten einfach organisieren und identifizieren. Die Tags werden sowohl für Azure als auch für Citrix ADM angewendet.

    Markierungen angeben

    Die Konfigurationseinstellungen werden überprüft, und auf der Registerkarte Überprüfen und erstellen wird das Ergebnis der Validierung angezeigt.

    • Wenn die Validierung fehlschlägt, zeigt diese Registerkarte den Grund für den Fehler an. Gehen Sie zurück zum jeweiligen Abschnitt und nehmen Sie ggf. Änderungen vor.
    • Wenn die Validierung erfolgreich ist, klicken Sie auf Erstellen. Der Prozess der Agentenbereitstellung beginnt.

      Zusammenfassung virtueller Rechner

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

    Bereitstellen von virtuellen

  6. Sobald der Agent mit einem SSH-Client einsatzbereit ist, melden Sie sich mit der öffentlichen IP-Adresse am Citrix ADM Agent an.

    Hinweis

     -  Wenn Sie den Benutzernamen als angegeben haben `nsrecover`, verwenden Sie die standardmäßigen Citrix ADM Agent-Anmeldeinformationen (**nsrecover/nsroot**), um sich bei der virtuellen Maschine anzumelden.
    
    • Citrix empfiehlt, das Standardkennwort nach der ersten Anmeldung zu ändern. Um das Kennwort zu ändern, geben Sie bei Shell Folgendes ein: passwd nsroot.
  7. Geben Sie den folgenden Befehl ein, um den Bereitstellungsbildschirm aufzurufen: deployment_type.py

  8. 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.

    Registrieren Sie den Agent

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.

Installieren des Citrix ADM-Agenten in der Microsoft Azure-Cloud