Erstellung und Bereitstellung eines Docker-IOx-Pakets für die IR1101 ARM-Architektur

Einleitung

Dieses Dokument beschreibt die Vorbereitung, den Aufbau und die Bereitstellung eines Docker-basierten IOx-Pakets für das IR1101 ARM-basierte Internet of Things (IoT)-Gateway.

Voraussetzungen

Anforderungen

Cisco empfiehlt, dass Sie über Kenntnisse in folgenden Bereichen verfügen:

• Linux 
• Container
• IOx

Verwendete Komponenten

Die Informationen in diesem Dokument basierend auf folgenden Software- und Hardware-Versionen:

• IR1101, erreichbar über Secure Shell (SSH)
  
  • IP-Adresse konfiguriert
  • Zugriff auf das Gerät mit der Berechtigung 15 Benutzer
• Linux-Host (eine minimale Debian 9 (Stretch)-Installation wird für diesen Artikel verwendet)
• IOx-Client-Installationsdateien, die von folgender Website heruntergeladen werden können: https://software.cisco.com/download/release.html?mdfid=286306005&softwareid=286306762

Die Informationen in diesem Dokument beziehen sich auf Geräte in einer speziell eingerichteten Testumgebung. Alle Geräte, die in diesem Dokument benutzt wurden, begannen mit einer gelöschten (Nichterfüllungs) Konfiguration. Wenn Ihr Netz Live ist, überprüfen Sie, ob Sie die mögliche Auswirkung jedes möglichen Befehls verstehen.

Hintergrundinformationen

Die IR1101 unterscheidet sich etwas von den meisten anderen IOx-Plattformen, da diese hauptsächlich auf x86 basieren. Die IR1101 basiert auf der ARM64v8-Architektur, sodass Sie keine Container oder IOx-Pakete, die für x86 erstellt wurden, direkt auf der Plattform bereitstellen können. Dieses Dokument beginnt bei Null und bereitet die Umgebung auf die Erstellung von ARM64v8-basierten Docker-Containern vor. Es erläutert, wie diese Container mithilfe eines x86-PCs erstellt, in Pakete verpackt und auf dem IR1101 bereitgestellt werden.

Als Beispiel wird ein sehr kleines Python-Skript verwendet, das ein einfacher Webserver ist, und es wird ein Docker-Container erstellt, um es schließlich zu verpacken, damit es auf dem IR1101 ausgeführt wird. Das einzige, was der Webserver tut, ist, auf einem vordefinierten Port (9000) zu hören und eine einfache Seite zurückzugeben, wenn er eine GET-Anfrage erhält. Auf diese Weise können Sie testen, ob Ihr eigener Code ausgeführt werden kann, und Sie können den Netzwerkzugriff auf die IOx-Anwendung testen, sobald diese ausgeführt wird.

Das Paket wird von den Docker-Tools unter Verwendung von Alpine Linux erstellt. Alpine Linux ist ein kleines Linux-Image (ca. 5MB), das oft als Basis für Docker-Container verwendet wird.

Da die meisten Desktop-/Laptop-/VM-Systeme alle x86-basiert sind, müssen Sie die ARM64v8-Architektur auf dem x86-basierten System emulieren, auf dem der Container erstellt wird. Dies ist ganz einfach mit der Quick Emulator (QEMU)-Benutzeremulation möglich. Dies ermöglicht die Ausführung von ausführbaren Dateien in einer nicht-nativen Architektur, genau wie sie auf der nativen Architektur ausgeführt würde.

Konfigurieren

Teil 1: Erstellung des IOx-Pakets für IR1101

1. Installieren und Vorbereiten des IOx-Clients auf dem Linux-Host

Sie benötigen ioxclient, um den Docker-Container als IOx-Paket zu verpacken, sobald er erstellt wurde, also lassen Sie uns dies zuerst vorbereiten.

Kopieren Sie zuerst das ioxclient-Paket oder laden Sie es herunter. Sie ist erhältlich unter: https://software.cisco.com/download/release.html?mdfid=286306005&softwareid=286306762.

jedepuyd@deb9:~$ scp jedepuyd@192.168.56.101:/home/jedepuyd/ioxclient_1.7.0.0_linux_amd64.tar.gz .
jedepuyd@192.168.56.101's password:
ioxclient_1.7.0.0_linux_amd64.tar.gz                             100% 4798KB  75.2MB/s   00:00

Extrahieren Sie das Paket:

jedepuyd@deb9:~$ tar -xvzf ioxclient_1.7.0.0_linux_amd64.tar.gz
ioxclient_1.7.0.0_linux_amd64/ioxclient
ioxclient_1.7.0.0_linux_amd64/README.md

Fügen Sie den Pfad zur PATH-Variablen hinzu, damit diese ohne die Verwendung des vollständigen Speicherorts verfügbar ist. Wenn Sie den Computer neu starten oder die Benutzer wechseln, vergessen Sie nicht, diesen Schritt zu wiederholen:

jedepuyd@deb9:~$ export PATH=$PATH:/home/jedepuyd/ioxclient_1.7.0.0_linux_amd64/

Starten Sie ioxclient zum ersten Mal, um ein obligatorisches Profil zu erstellen. Da Sie ioxclient nur zum Verpacken des Docker-Containers verwenden, können die Werte als Standard beibehalten werden:

jedepuyd@deb9:~$ ioxclient -v
ioxclient version 1.7.0.0
jedepuyd@deb9:~/iox_aarch64_webserver$ ioxclient profiles reset
Active Profile :  default
Your current config details will be lost. Continue (y/N) ? : y
Current config backed up at  /tmp/ioxclient731611124
Config data deleted.
jedepuyd@deb9:~/iox_aarch64_webserver$ ioxclient -v
Config file not found :  /home/jedepuyd/.ioxclientcfg.yaml
Creating one time configuration..
Your / your organization's name :
Your / your organization's URL :
Your IOx platform's IP address[127.0.0.1] :
Your IOx platform's port number[8443] :
Authorized user name[root] :
Password for root :
Local repository path on IOx platform[/software/downloads]:
URL Scheme (http/https) [https]:
API Prefix[/iox/api/v2/hosting/]:
Your IOx platform's SSH Port[2222]:
Your RSA key, for signing packages, in PEM format[]:
Your x.509 certificate in PEM format[]:
Activating Profile  default
Saving current configuration
ioxclient version 1.7.0.0

2. Installieren und Vorbereiten der Docker-Umgebung auf dem Linux-Buildcomputer

Dieser Docker wird verwendet, um einen Container aus dem Alpine-Basisbild zu erstellen und die erforderlichen Dateien für den Anwendungsfall einzuschließen. Die angegebenen Schritte basieren auf den offiziellen Installationsanleitungen von Docker Community Edition (CE) für Debian: https://docs.docker.com/install/linux/docker-ce/debian/

Aktualisieren Sie die Paketlisten auf Ihrem Computer:

jedepuyd@deb9:~$ sudo apt-get update
...
Reading package lists... Done

Installieren Sie die Abhängigkeiten, um das Docker-Repo zu verwenden:

jedepuyd@deb9:~$ sudo apt-get install apt-transport-https ca-certificates curl gnupg2 software-properties-common
Reading package lists... Done
Building dependency tree
...
Processing triggers for dbus (1.10.26-0+deb9u1) ...

Fügen Sie den Docker GNU Privacy Guard (GPG)-Schlüssel als gültigen GPG-Schlüssel hinzu:

jedepuyd@deb9:~$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
OK

Überprüfen Sie den Fingerabdruck des installierten GPG-Schlüssels:

jedepuyd@deb9:~$ sudo apt-key fingerprint 0EBFCD88
pub   rsa4096 2017-02-22 [SCEA]
      9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid           [ unknown] Docker Release (CE deb) <docker@docker.com>
sub   rsa4096 2017-02-22 [S]

Fügen Sie das Docker Stable Repo hinzu:

jedepuyd@deb9:~$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"

Aktualisieren Sie die Paketlisten erneut, wenn Sie das Docker-Repo hinzufügen:

jedepuyd@deb9:~$ sudo apt-get update
...
Reading package lists... Done

Docker installieren:

jedepuyd@deb9:~$ sudo apt-get install docker-ce docker-ce-cli containerd.io
Reading package lists... Done
Building dependency tree
...
Processing triggers for systemd (232-25+deb9u9) ...

Um als regulärer Benutzer auf Docker zugreifen und es ausführen zu können, fügen Sie diesen Benutzer zur Docker-Gruppe hinzu, und aktualisieren Sie die Gruppenmitgliedschaft:

jedepuyd@deb9:~$ sudo usermod -a -G docker jedepuyd
jedepuyd@deb9:~$ newgrp docker

3. QEMU-Benutzeremulationspakete installieren

Nachdem Sie Docker installiert haben, müssen Sie die QEMU-Benutzeremulatoren installieren. Verwenden Sie den statisch verknüpften QEMU-Emulator aus dem Docker-Container, damit Sie den Container für ARM64v8 auf unserer x86-basierten Linux-Maschine ausführen können, obwohl der Zielcontainer für die ARM64v8-Architektur konzipiert ist.

Installieren Sie die Pakete:

jedepuyd@deb9:~$ sudo apt-get install qemu-user qemu-user-static
Reading package lists... Done
Building dependency tree
...
Processing triggers for man-db (2.7.6.1-2) ...

Nach der Installation sind hier die statisch verknüpften QEMU-Emulatoren in /usr/bin verfügbar:

jedepuyd@deb9:~$ ls -al /usr/bin/qemu-*static
-rwxr-xr-x 1 root root 3468784 Nov  8 16:41 /usr/bin/qemu-aarch64-static
-rwxr-xr-x 1 root root 2791408 Nov  8 16:41 /usr/bin/qemu-alpha-static
-rwxr-xr-x 1 root root 3399344 Nov  8 16:41 /usr/bin/qemu-armeb-static
-rwxr-xr-x 1 root root 3391152 Nov  8 16:41 /usr/bin/qemu-arm-static
-rwxr-xr-x 1 root root 2800400 Nov  8 16:41 /usr/bin/qemu-cris-static
...

Die erste in der Liste ist die, die Sie brauchen: aarch64 ist der Arch-Name für ARM64v8 für Linux.

4. Testen Sie, ob ein aarch64/ARV64v8 Container auf x86-Linux-Maschine läuft

Nachdem Sie Docker und die erforderlichen QEMU-Binärdateien installiert haben, können Sie testen, ob Sie einen Docker-Container für ARM64v8 auf dem x86-System ausführen können:

jedepuyd@deb9:~$ docker run -v /usr/bin/qemu-aarch64-static:/usr/bin/qemu-aarch64-static --rm -ti arm64v8/alpine:3.7
Unable to find image 'arm64v8/alpine:3.7' locally
3.7: Pulling from arm64v8/alpine
40223db5366f: Pull complete
Digest: sha256:a50c0cd3b41129046184591963a7a76822777736258e5ade8445b07c88bfdcc3
Status: Downloaded newer image for arm64v8/alpine:3.7
/ # uname -a
Linux 1dbba69b60c5 4.9.0-8-amd64 #1 SMP Debian 4.9.144-3.1 (2019-02-19) aarch64 Linux

Wie Sie in der Ausgabe sehen können, arm64v8 Alpine Container erhalten und gemacht, um mit Zugriff auf den Emulator laufen. 

Wenn Sie die Architektur des Containers anfordern, können Sie sehen, dass der Code für arch64 kompiliert wird. Genau wie der Zielbogen für den Container muss für IR1101 sein.

5. Vorbereiten von Dateien zum Erstellen des Docker-Webservercontainers

Nachdem alle Vorbereitungen abgeschlossen sind, können Sie die notwendigen Dateien für den Webserver-Container erstellen, der auf IR1101 ausgeführt werden muss.

Die erste Datei ist webserver.py, das Python-Skript, das im Container ausgeführt werden soll. Da dies nur ein Beispiel ist, ersetzen Sie dies natürlich durch den eigentlichen Code, um ihn in Ihrer IOx-Anwendung auszuführen:

jedepuyd@deb9:~$ mkdir iox_aarch64_webserver
jedepuyd@deb9:~$ cd iox_aarch64_webserver

jedepuyd@deb9:~/iox_aarch64_webserver$ vi webserver.py
jedepuyd@deb9:~/iox_aarch64_webserver$ cat webserver.py
#!/usr/bin/env python
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import SocketServer
import os

class S(BaseHTTPRequestHandler):
    def _set_headers(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_GET(self):
        self._set_headers()
        self.wfile.write("<html><body><h1>IOX python webserver on arm64v8</h1></body></html>")
        logf.write('Got GET\n')
        logf.flush()

def run(server_class=HTTPServer, handler_class=S, port=9000):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    print 'Starting webserver...'
    logf.write('Starting webserver....\n')
    logf.flush()
    httpd.serve_forever()

if __name__ == "__main__":
    log_file_dir = os.getenv("CAF_APP_LOG_DIR", "/tmp")
    log_file_path = os.path.join(log_file_dir, "webserver.log")
    logf = open(log_file_path, 'w')
    run()
    logf.close()

Dieser Code enthält die Logik zum Schreiben in eine Protokolldatei, die vom lokalen Manager eingesehen werden kann.

Die zweite Datei, die benötigt wird, ist die Dockerfile. Dies definiert, wie der Container erstellt wird:

jedepuyd@deb9:~/iox_aarch64_webserver$ vi Dockerfile
jedepuyd@deb9:~/iox_aarch64_webserver$ cat Dockerfile
FROM arm64v8/alpine:3.7
COPY qemu-aarch64-static /usr/bin

RUN apk add --no-cache python
COPY webserver.py /webserver.py

Die Dockerdatei definiert, wie der Container erstellt wird. Starten Sie vom Apline-Basis-Image für ARM64v8, kopieren Sie den Emulator in den Container, führen Sie den apk aus, um das Python-Paket hinzuzufügen, und kopieren Sie das Webserver-Skript in den Container.

Die letzte Vorbereitung, die erforderlich ist, bevor Sie den Container erstellen können, besteht darin, qemu-aarch64-static in das Verzeichnis zu kopieren, aus dem Sie den Container erstellen:

jedepuyd@deb9:~/iox_aarch64_webserver$ cp /usr/bin/qemu-aarch64-static .

6. Bauen Sie den Docker Container

Nachdem die Vorbereitung abgeschlossen ist, können Sie den Container mithilfe der Dockerfile erstellen:

jedepuyd@deb9:~/iox_aarch64_webserver$ docker build -t iox_aarch64_webserver .
Sending build context to Docker daemon  3.473MB
Step 1/4 : FROM arm64v8/alpine:3.7
 ---> e013d5426294
Step 2/4 : COPY qemu-aarch64-static /usr/bin
 ---> addf4e1cc965
Step 3/4 : RUN apk add --no-cache python
 ---> Running in ff3768926645
fetch http://dl-cdn.alpinelinux.org/alpine/v3.7/main/aarch64/APKINDEX.tar.gz
fetch http://dl-cdn.alpinelinux.org/alpine/v3.7/community/aarch64/APKINDEX.tar.gz
(1/10) Installing libbz2 (1.0.6-r6)
(2/10) Installing expat (2.2.5-r0)
(3/10) Installing libffi (3.2.1-r4)
(4/10) Installing gdbm (1.13-r1)
(5/10) Installing ncurses-terminfo-base (6.0_p20171125-r1)
(6/10) Installing ncurses-terminfo (6.0_p20171125-r1)
(7/10) Installing ncurses-libs (6.0_p20171125-r1)
(8/10) Installing readline (7.0.003-r0)
(9/10) Installing sqlite-libs (3.25.3-r0)
(10/10) Installing python2 (2.7.15-r2)
Executing busybox-1.27.2-r11.trigger
OK: 51 MiB in 23 packages
Removing intermediate container ff3768926645
 ---> eda469dab9c6
Step 4/4 : COPY webserver.py /webserver.py
 ---> ccf7ee7227c9
Successfully built ccf7ee7227c9
Successfully tagged iox_aarch64_webserver:latest

Führen Sie als Test den soeben erstellten Container aus, und überprüfen Sie, ob das Skript funktioniert:

jedepuyd@deb9:~/iox_aarch64_webserver$ docker run -ti iox_aarch64_webserver
/ # uname -a
Linux dae047f1a6b2 4.9.0-8-amd64 #1 SMP Debian 4.9.144-3.1 (2019-02-19) aarch64 Linux
/ # python webserver.py &
/ # Starting webserver...

/ # netstat -tlpn
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name   
tcp        0      0 0.0.0.0:9000            0.0.0.0:*               LISTEN      13/qemu-aarch64-sta
/ # exit

Wie Sie in dieser Ausgabe sehen können, ist die Architektur des Containers das Ziel aarch64. Und nachdem Sie das Skript gestartet haben, sehen Sie, dass es auf Anfragen von Port 9000 wartet.

 7. IOx-Paket erstellen

Der Behälter ist verpackungsbereit. Bevor Sie ioxclient bitten können, dies zu tun, müssen Sie zuerst den Paketdeskriptor erstellen: package.yaml.

In dieser Datei wird beschrieben, wie das Paket aussieht, wie viele Ressourcen es ausführen muss und was gestartet werden muss.

jedepuyd@deb9:~/iox_aarch64_webserver$ vi package.yaml
jedepuyd@deb9:~/iox_aarch64_webserver$ cat package.yaml
descriptor-schema-version: "2.7"

info:
  name: "iox_aarch64_webserver"
  description: "simple docker webserver for arm64v8"
  version: "1.0"
  author-link: "http://www.cisco.com"
  author-name: "Jens Depuydt"

app:
  cpuarch: "aarch64"
  type: "docker"
  resources:
    profile: c1.tiny
    network:
      -
        interface-name: eth0
        ports:
          tcp: ["9000"]

  startup:
    rootfs: rootfs.tar
    target: ["python","/webserver.py"]

Wie Sie sehen, ist die CPU-Architektur auf aarch64 eingestellt. Um auf den TCP-Port 9000 zuzugreifen, verwenden Sie rootfs.tar als rootfs, und führen Sie beim Start die Datei python/webserver.py aus.

Das Letzte, was zu tun ist, bevor Sie verpacken können, ist, die rootfs.tar aus dem Docker-Container zu extrahieren:

jedepuyd@deb9:~/iox_aarch64_webserver$ docker save -o rootfs.tar iox_aarch64_webserver

An dieser Stelle können Sie ioxclient verwenden, um das IOx-Paket für IR1101 zu erstellen:

jedepuyd@deb9:~/iox_aarch64_webserver$ ioxclient package .
Currently active profile :  default
Command Name:  package
No rsa key and/or certificate files provided to sign the package
Checking if package descriptor file is present..
Validating descriptor file /home/jedepuyd/iox_aarch64_webserver/package.yaml with package schema definitions
Parsing descriptor file..
Found schema version  2.7
Loading schema file for version  2.7
Validating package descriptor file..
File /home/jedepuyd/iox_aarch64_webserver/package.yaml is valid under schema version 2.7
Created Staging directory at :  /tmp/017226485
Copying contents to staging directory
Creating an inner envelope for application artifacts
Generated  /tmp/017226485/artifacts.tar.gz
Calculating SHA1 checksum for package contents..
Updated package metadata file :  /tmp/017226485/.package.metadata
Root Directory :  /tmp/017226485
Output file:  /tmp/475248592
Path:  .package.metadata
SHA1 : 95abe28fc05395fc5f71f7c28f59eceb1495bf9b
Path:  artifacts.tar.gz
SHA1 : bdf5596a0747eae51bb0a1d2870fd09a5a16a098
Path:  package.yaml
SHA1 : e65a6fcbe96725dd5a09b60036448106acc0c138
Generated package manifest at  package.mf
Generating IOx Package..
Package generated at /home/jedepuyd/iox_aarch64_webserver/package.tar

Im Moment gibt es ein Paket, um auf dem IR1101 bereitzustellen bereit als package.tar. Im nächsten Teil wird erläutert, wie das Gerät für die Bereitstellung vorbereitet wird.

Teil 2: Konfigurieren des IR1101 für IOx

1. Aktivieren Sie Webinterface, IOx und Local Manager.

Local Manager ist eine grafische Benutzeroberfläche (GUI) zum Bereitstellen, Aktivieren, Starten, Verwalten und Beheben von IOx-Anwendungen. Für IR1101 ist es in die reguläre Management-Webschnittstelle integriert. Sie müssen diese Funktion also zuerst aktivieren.

Führen Sie diese Schritte für den IR1101 aus, um IOx und die Webschnittstelle zu aktivieren.

BRU_IR1101_20#conf t
Enter configuration commands, one per line.  End with CNTL/Z.
BRU_IR1101_20(config)#iox
BRU_IR1101_20(config)#ip http server
BRU_IR1101_20(config)#ip http secure-server
BRU_IR1101_20(config)#ip http authentication local
BRU_IR1101_20(config)#username admin privilege 15 password 0 cisco

In der letzten Zeile wird ein Benutzer mit den Berechtigungen 15 hinzugefügt. Dieser Benutzer hat Zugriff auf die Webschnittstelle und den lokalen IOx-Manager.

2. Konfigurieren von IOx-Netzwerken

Bevor Sie auf die Webschnittstelle zugreifen, lassen Sie uns die erforderliche Konfiguration für das IOx-Netzwerk hinzufügen. Hintergrundinformationen finden Sie in der IR1101-Dokumentation für IOx: https://www.cisco.com/c/en/us/td/docs/routers/access/1101/software/configuration/guide/b-cisco-ir1101-scg.html

Kurz gesagt, die IOx-Anwendungen können mit der VirtualPortGroup0-Schnittstelle (vergleichbar mit Gi2 bei IR809 und Gi5 bei IR829-Schnittstellen) mit der Außenwelt kommunizieren.

BRU_IR1101_20(config)#interface VirtualPortGroup0
BRU_IR1101_20(config-if)# ip address 192.168.1.1 255.255.255.0
BRU_IR1101_20(config-if)# ip nat inside
BRU_IR1101_20(config-if)# ip virtual-reassembly
BRU_IR1101_20(config-if)#exit

Wenn Sie die VirtualPortGroup0-Schnittstelle innen als Network Address Translation (NAT) konfigurieren, müssen Sie die Anweisung ip nat outside auf der Gi 0/0/0-Schnittstelle hinzufügen, um die Kommunikation zu und von den IOx-Anwendungen unter Verwendung von NAT zu ermöglichen:

BRU_IR1101_20(config)#interface gigabitEthernet 0/0/0
BRU_IR1101_20(config-if)#ip nat outside
BRU_IR1101_20(config-if)#ip virtual-reassembly

Um den Zugriff auf Port 9000 für den Container zu ermöglichen, den Sie 192.168.1.15 zuweisen können, müssen Sie einen Port Forward hinzufügen:

BRU_IR1101_20(config)#$ip nat inside source static tcp 192.168.1.15 9000 interface GigabitEthernet0/0/0 9000

Verwenden Sie für diese Anleitung statisch konfigurierte IPs pro IOx-Anwendung. Wenn Sie den Anwendungen dynamisch IP-Adressen zuweisen möchten, müssen Sie die Konfiguration für einen DHCP-Server im Subnetz von VirtualPortGroup0 hinzufügen.

Teil 3: Auf Local Manager zugreifen und IOx-Anwendung bereitstellen

Nachdem Sie diese Leitungen zur Konfiguration hinzugefügt haben, können Sie über die Webschnittstelle auf die IR1101 zugreifen. Navigieren Sie zur IP-Adresse Gi 0/0/0 mit dem Browser, wie im Bild dargestellt.

Verwenden Sie das in Schritt 1 erstellte Konto "privilege 15", um sich bei der Webschnittstelle anzumelden und zu "Configuration - IOx" (Konfiguration - IOx) zu navigieren, wie im Bild dargestellt.

Verwenden Sie bei der IOx Local Manager-Anmeldung dasselbe Konto, um fortzufahren, wie im Bild gezeigt.

Klicken Sie auf Add New (Neu hinzufügen), wählen Sie einen Namen für die IOx-Anwendung aus, und wählen Sie die Datei package.tar aus, die in Teil 1 wie im Bild dargestellt erstellt wurde.

Sobald das Paket hochgeladen ist, können Sie es aktivieren, wie im Bild gezeigt.

Öffnen Sie auf der Registerkarte Resources die Schnittstelleneinstellung, um die feste IP-Adresse anzugeben, die Sie der App wie im Bild dargestellt zuweisen möchten.

Klicken Sie auf OK und dann auf Aktivieren. Wenn die Aktion abgeschlossen ist, navigieren Sie zurück zur Hauptseite für den lokalen Manager (Schaltfläche "Anwendungen" im oberen Menü), und starten Sie die Anwendung wie im Bild dargestellt.

Nachdem Sie diese Schritte durchlaufen haben, wird Ihre Anwendung ausgeführt und ist über Port 9000 verfügbar, wobei die Gi 0/0/0-Schnittstelle des IR1101 verwendet wird.

Überprüfung

Verwenden Sie diesen Abschnitt, um zu überprüfen, ob Ihre Konfiguration ordnungsgemäß funktioniert.

Um dies zu überprüfen, können Sie über den Port 9000 auf die IP-Adresse der Gi 0/0/0-Schnittstelle des IR1101 zugreifen.

Wenn alles gut geht, wird dies angezeigt, wie es im Python-Skript erstellt wurde.

Fehlerbehebung

In diesem Abschnitt erhalten Sie Informationen zur Behebung von Fehlern in Ihrer Konfiguration.

Zur Fehlerbehebung können Sie die Protokolldatei, die Sie im Python-Skript erstellen, mithilfe eines lokalen Managers überprüfen.

Navigieren Sie zu Anwendungen, klicken Sie in der iox_web-Anwendung auf Verwalten, und wählen Sie dann die Registerkarte Protokolle wie im Bild dargestellt aus.