Installieren eines NetScaler-Agenten auf Amazon Web Services (AWS)

Voraussetzungen

Um ein NetScaler-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 AWS Virtual Private Cloud (VPC)

Ein IAM-Konto

Eine Service-URL und einen Aktivierungscode, damit sich der Agent mit dem NetScaler Console-Dienst verbinden kann. Navigieren Sie in der NetScaler Console-Dienst-GUI zu Infrastructure > Instances > Agents und klicken Sie auf Generate Activation Code, um Ihre Service-URL und Ihren Aktivierungscode zu generieren.

Hinweis

Bevor Sie eine virtuelle NetScaler-Agent-Maschine bereitstellen, empfiehlt Citrix, Sicherheitsgruppen, virtuelle private Netzwerke, Schlüsselpaare, Subnetze und andere Entitäten zu erstellen. So sind die Netzwerkinformationen während der Bereitstellung verfügbar.
Damit ein NetScaler-Agent mit der NetScaler Console und den NetScaler-Instanzen kommunizieren kann, stellen Sie sicher, dass die empfohlenen Ports geöffnet sind. Vollständige Details zu den Portanforderungen für einen NetScaler-Agenten finden Sie unter Ports.

So installieren Sie den NetScaler-Agenten auf AWS:

Melden Sie sich mit Ihren AWS-Anmeldeinformationen beim AWS Marketplace an.

Geben Sie im Suchfeld NetScaler agent ein, um nach dem NetScaler-Agent-AMI zu suchen, und klicken Sie auf Go.

Klicken Sie auf der Suchergebnisseite in der verfügbaren Liste auf das NetScaler Console External agent AMI.

Klicken Sie auf der Seite NetScaler Console External Agent AMI auf Continue to Subscribe.

NetScaler Console externer Agent

Nach erfolgreicher Registrierung klicken Sie auf Continue to Configuration.

Konfiguration fortsetzen

Auf der Seite Configure this software:

Wählen Sie das AMI aus der Liste Fulfillment option aus.
Wählen Sie die neueste NetScaler-Agent-Version aus der Liste Software Version aus.
Wählen Sie Ihre Region aus der Liste Region aus.
Klicken Sie auf Continue to Launch

Auf der Seite Launch this software haben Sie zwei Optionen, um den NetScaler-Agenten zu registrieren:

Starten von der Website
Starten mit EC2

Starten von einer Website

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

Einen EC2-Instanztyp aus der Liste EC2 Instance Type

Eine VPC aus der Liste VPC Settings. Klicken Sie auf Create a VPC in EC2, um eine VPC für Ihre Software zu erstellen.

Ein Subnetz aus der Liste Subnet Settings. Klicken Sie auf Create a subnet in EC2, um ein Subnetz zu erstellen, nachdem Sie die VPC ausgewählt haben.

Eine Sicherheitsgruppe für die Firewall aus der Liste Security Group Settings. Klicken Sie auf Create New Based On Seller Settings, um eine Sicherheitsgruppe zu erstellen.

Ein Schlüsselpaar zur Gewährleistung der Zugriffssicherheit aus der Liste Key Pair Settings. Klicken Sie auf Create a key pair in EC2, um ein Schlüsselpaar für Ihre Software zu erstellen.

Klicken Sie auf Launch

Eine Website starten

Der Start von einer Website war erfolgreich.

Start von einer Website erfolgreich

Hinweis

Der Bereitstellungsprozess kann etwa 10–15 Minuten dauern. Nach erfolgreicher Bereitstellung können Sie Ihre virtuelle NetScaler-Agent-Maschine in Ihrem AWS-Konto anzeigen.

Sobald der Agent bereitgestellt ist, weisen Sie Ihrem NetScaler-Agenten einen Namen zu.

Sobald der Agent läuft, weisen Sie Ihrem NetScaler-Agenten eine elastische IP-Adresse zu.

Hinweis

Eine elastische IP-Adresse ermöglicht dem NetScaler-Agenten die Kommunikation mit der NetScaler Console. Eine elastische IP-Adresse ist jedoch möglicherweise nicht erforderlich, wenn Sie ein NAT-Gateway konfiguriert haben, um den Datenverkehr ins Internet zu leiten.

Melden Sie sich mit einem SSH-Client bei Ihrem NetScaler-Agenten an.

Hinweis

Sie können sich auf eine der folgenden Weisen beim NetScaler-Agenten anmelden:

Verwenden Sie nsrecover als Benutzernamen und die AWS-Instanz-ID als Passwort.

Verwenden Sie nsroot als Benutzernamen und ein gültiges Schlüsselpaar als Passwort.

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

Geben Sie die Service-URL und den Aktivierungscode ein, die Sie von der Seite Set Up Agents in der NetScaler Console kopiert und gespeichert haben, wie unter Erste Schritte beschrieben. Der Agent verwendet die Service-URL, um den Dienst zu finden, und den Aktivierungscode, um sich beim Dienst zu registrieren.

NetScaler Console Bereitstellung

Nach erfolgreicher Agentenregistrierung startet der Agent neu, um den Installationsprozess abzuschließen.

Nachdem der Agent neu gestartet wurde, greifen Sie auf die NetScaler Console zu und überprüfen Sie auf der Seite Set Up Agent unter Discovered Agents den Status des Agenten.

Starten mit EC2

Um mit EC2 zu starten, wählen Sie Launch through EC2 aus der Liste Choose Action und klicken Sie dann auf Launch.

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

Instanzdetails konfigurieren

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

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

Authentifizierungsdetails – Geben Sie die Service-URL und den Aktivierungscode an, die Sie von der Seite Set Up Agents in der NetScaler Console kopiert haben, wie unter Erste Schritte beschrieben. Geben Sie die Details im folgenden Format ein.
```
 registeragent -serviceurl <apigatewayurl> -activationcode <activationcodevalue>
 
```
Der Agent verwendet diese Informationen, um sich während des Systemstarts automatisch bei der NetScaler Console zu registrieren.

Skript – Geben Sie ein Skript zur automatischen Agentenregistrierung 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 a NetScaler agent with NetScaler Console. Pass it in userdata to make NetScaler agent in AWS to autoregister on bootup. The workflow is as follows
 1)  Fetch the NetScaler Console API credentials (ID and secret) from AWS secret store (NOTE: you have to assign IAM role to the NetScaler agent that will give permission to fetch secrets from AWS secret store)
 2)  Login to NetScaler Console with credentials fetched in step 1
 3)  Call NetScaler Console to fetch credentials (serviceURL and token) for agent registration
 4)  Calls registration by using the credentials fetched in step 3
 '''

 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 NetScaler Console credentials from AWS secret failed with error: %s" % (str(e)))
     raise e

 '''
 Initializing common NetScaler Console API handlers
 '''
 mas_common_headers = {
     'Content-Type': "application/json",
     'Accept-type': "application/json",
     'Connection': "keep-alive",
     'isCloud': "true"
 }

 '''
 API to login to the NetScaler Console 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 NetScaler Console 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 NetScaler Console
 '''
 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 Skript deployment.py aus, um den Agenten bei der NetScaler Console zu registrieren.

Instanzdetails konfigurieren

Hinweis

Während Sie automatisch eine öffentliche IP-Adresse zuweisen können, können Sie auch eine elastische IP-Adresse zuweisen. Die Zuweisung einer elastischen IP-Adresse ist erforderlich, wenn kein NAT-Gateway konfiguriert ist.

Wenn die elastische IP-Adresse in diesem Schritt nicht festgelegt wird, können Sie dies immer noch in der EC2-Konsole tun. Sie können eine neue elastische IP-Adresse erstellen und diese dem NetScaler-Agenten mithilfe der Instanz-ID oder ENI-ID zuordnen.

Klicken Sie auf Add Storage.

Konfigurieren Sie auf der Seite Add Storage die Einstellungen für das Speichergerät der Instanz und klicken Sie auf Next: Add Tags.

Tags hinzufügen

Definieren Sie auf der Seite Add Tags den Tag für die Instanz und klicken Sie auf Next: Configure Security Group.

Sicherheitsgruppe konfigurieren

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

Überprüfen und starten

Überprüfen Sie auf der Seite Review Instance Launch die Instanzeinstellungen und klicken Sie auf Launch.

Erstellen Sie im Dialogfeld Select an existing key pair or create a new key pair ein Schlüsselpaar. Sie können auch aus den vorhandenen Schlüsselpaaren auswählen.

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

Instanzen starten

Der Bereitstellungsprozess kann etwa 10–15 Minuten dauern. Nach erfolgreicher Bereitstellung können Sie Ihre virtuelle NetScaler-Agent-Maschine in Ihrem AWS-Konto anzeigen.

War dieser Artikel hilfreich?

NetScaler Secure Deployment Guide