Bouw en implementeer een Docker IOx-pakket voor de IR1101 ARM-architectuur

Inleiding

In dit document wordt beschreven hoe een Docker-gebaseerde IOx-pakket voor de IR1101 ARM-gebaseerde Internet of Things (IoT)-gateway moet worden voorbereid, gebouwd en geïmplementeerd.

Voorwaarden

Vereisten

Cisco raadt kennis van de volgende onderwerpen aan:

• Linux
• Containers
• IOSx

Gebruikte componenten

De informatie in dit document is gebaseerd op de volgende software- en hardware-versies:

• IR1101 die via Secure Shell (SSH) kan worden bereikt
  
  • IP-adres ingesteld
  • Toegang tot het apparaat met een voorrecht 15 gebruiker
• Linux-host (een minimale installatie van Debian 9 (stretch) wordt gebruikt voor dit artikel)
• IOx client installatie bestanden die kunnen worden gedownload van: https://software.cisco.com/download/release.html?mdfid=286306005&softwareid=286306762

De informatie in dit document is gebaseerd op de apparaten in een specifieke laboratoriumomgeving. Alle apparaten die in dit document worden beschreven, hadden een opgeschoonde (standaard)configuratie. Als uw netwerk live is, moet u de potentiële impact van elke opdracht begrijpen.

Achtergrondinformatie

De IR1101 is een beetje anders in vergelijking met de meeste andere IOx-platforms omdat deze voornamelijk op x86 gebaseerd zijn. De IR1101 is gebaseerd op de ARM64v8-architectuur, zodat u geen containers of IOx-pakketten kunt implementeren die voor x86 direct op het platform zijn gebouwd. Dit document begint bij nul en bereidt de omgeving voor voor het bouwen van op ARM64v8 gebaseerde Docker containers en legt uit hoe ze te bouwen, te verpakken en te implementeren op de IR1101 met het gebruik van een x86 PC.

Bijvoorbeeld, een zeer klein Python script dat een eenvoudige webserver is wordt gebruikt en een Docker container wordt gebouwd om het uiteindelijk te verpakken om te draaien op de IR1101. Het enige wat de webserver doet is te luisteren op een vooraf gedefinieerde poort (9000) en een eenvoudige pagina terug te sturen wanneer het een GET aanvraag ontvangt. Hiermee kunt u de mogelijkheid testen om uw eigen code uit te voeren en kunt u de netwerktoegang tot de IOx-toepassing testen zodra deze start.

Het pakket is gebouwd door de Docker tools, met het gebruik van Alpine Linux. Alpine Linux is een kleine Linux afbeelding (rond 5MB), die vaak wordt gebruikt als basis voor Docker containers.

Aangezien de meeste desktops/laptops/VM's in de omgeving allemaal x86-gebaseerd zijn, moet u de ARM64v8-architectuur nastreven op de x86-gebaseerde machine waar de container is gebouwd. U kunt dit gemakkelijk doen met het gebruik van Quick Emulator (QEMU) gebruikersemulatie. Dit maakt het mogelijk om executables uit te voeren in een niet-native architectuur net zoals het zou draaien op zijn eigen architectuur.

Configureren

Deel 1. Bouw het IOx-pakket voor IR1101

1. Installeer en bereid IOx Client voor op de Linux Host

Je hebt ioxclient nodig om de Docker container als een IOx pakket te verpakken zodra het is gebouwd, dus laten we dit eerst voorbereiden.

Eerste kopie of download het ioxclient pakket. Het is beschikbaar op: 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

Haal de verpakking eruit:

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

Voeg het pad toe aan de variabele PATH zodat het beschikbaar is zonder gebruik van de volledige locatie. Als u het apparaat of de switch opnieuw opstart, vergeet dan niet deze stap te herhalen:

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

Start ioxclient voor het eerst om een verplicht profiel te maken. Aangezien u alleen ioxclient gebruikt om de Docker container te verpakken, kunnen de waarden standaard worden achtergelaten:

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. Installeer en bereid de Docker Environment voor op de Linux Build Machine

Deze Docker wordt gebruikt om een container van het basisbeeld van de Alpen te bouwen en de nodige bestanden voor de use case op te nemen. De gegeven stappen zijn gebaseerd op de officiële installatiehandleidingen van Docker Community Edition (CE) voor Debian: https://docs.docker.com/install/linux/docker-ce/debian/

Werk de pakketlijsten op uw machine bij:

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

Installeer de afhankelijkheden om de Docker repo te gebruiken:

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

Voeg de Docker GNU Privacy Guard (GPG) toets toe als geldige GPG-toets:

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

Controleer de vingerafdruk van de geïnstalleerde GPG-toets:

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]

Voeg de Docker stabiele repo toe:

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

Werk de pakketlijsten opnieuw bij als u de Docker-repo toevoegt:

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

Installeer Docker:

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

Om Docker als een reguliere gebruiker te kunnen benaderen/uitvoeren, voegt u deze gebruiker toe aan de Docker-groep en vernieuwt u het groepslidmaatschap:

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

3. Installeer de QEMU User Emulation-pakketten

Nadat u Docker hebt geïnstalleerd, moet u de QEMU-gebruikersemulators installeren. Gebruik de statisch gekoppelde QEMU emulator vanuit de Docker container zodat u de container voor ARM64v8 op onze x86-gebaseerde Linux-machine kunt draaien, hoewel de doelcontainer is ontworpen voor de ARM64v8-architectuur.

Installeer de pakketten:

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

Na de installatie, hier zijn de statisch verbonden QEMU emulators beschikbaar in /usr/bin:

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

De eerste in de lijst, is degene die je nodig hebt: aarch64 is de boognaam voor ARM64v8 voor Linux.

4. Test als een aarch64/ARV64v8 Container draait op x86 Linux Machine

Nu u Docker en de benodigde QEMU binaries hebt geïnstalleerd, kunt u testen of u een Docker container die voor ARM64v8 is gebouwd op de x86 machine kunt draaien:

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

Zoals u kunt zien in de uitvoer, arm64v8 Alpine container wordt verkregen en gemaakt om te lopen met toegang tot de emulator. 

Als u om de architectuur van de container verzoekt, kunt u zien dat de code voor aarch64 wordt gecompileerd. Precies zoals de doelboog voor de container voor IR1101 moet zijn.

5. Bestanden voorbereiden om de Docker Webserver Container te bouwen

Nu alle voorbereiding is gedaan, kunt u doorgaan en de nodige bestanden maken voor de webservercontainer die moet worden uitgevoerd op IR1101.

Het eerste bestand is webserver.py, het Python script dat u wilt uitvoeren in de container. Aangezien dit slechts een voorbeeld is, natuurlijk, vervangt u dit met de daadwerkelijke code om in uw toepassing van IOx te lopen:

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()

Deze code bevat de logica om naar een logbestand te schrijven, dat kan worden geraadpleegd bij Local Manager.

Het tweede bestand dat nodig is, is het Dockerfile. Dit bepaalt hoe de container wordt gebouwd:

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

Het Dockerfile-bestand bepaalt hoe de container wordt gebouwd. Begin van het Apline basisbeeld voor ARM64v8, kopieer de emulator in de container, voer het pakket uit om het Python-pakket toe te voegen en kopieer het webserverscript naar de container.

De laatste voorbereiding die nodig is voordat u de container kunt bouwen is om qemu-aarch64-statisch naar de directory te kopiëren van waar u de container bouwt:

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

6. Bouw de Docker Container

Nu alle voorbereiding is gedaan, kunt u de container bouwen met het gebruik van de Dockerfile:

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

Als test, voer de container die u net gebouwd en controleer of het script werkt:

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

Zoals je kunt zien in deze output, is de architectuur van de container de beoogde aarch64. Nadat je het script start, zie je dat het luistert naar verzoeken op poort 9000.

 7. Bouw het IOx-pakket

De container is klaar om verpakt te worden. Alvorens u ioxclient kunt vragen om dit te doen, moet u eerst de pakket descriptor aanmaken: package.yaml.

Dit bestand beschrijft hoe het pakket eruitziet, hoeveel bronnen het moet uitvoeren en wat te starten.

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"]

Zoals u kunt zien, is de CPU-architectuur ingesteld op aarch64. Om toegang te krijgen tot TCP poort 9000, gebruik rootfs.tar als de rootfs en op start, kunt u python/webserver.py uitvoeren.

Het laatste wat je moet doen voordat je kunt verpakken is om de rootfs.tar uit de Docker container te halen:

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

Op dit punt kunt u ioxclient gebruiken om het IOx-pakket voor IR1101 te bouwen:

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

Op dit moment is er een pakket om te kunnen inzetten op de IR1101 als package.tar. In het volgende deel wordt uitgelegd hoe u het apparaat voor implementatie moet voorbereiden.

Deel 2. De IR1101 voor IOx configureren

1. Schakel de Webinterface, IOx en Local Manager in

Local Manager is een GUI om IOx-toepassingen te implementeren, te activeren, te starten, te beheren en problemen op te lossen. Voor IR1101, is het ingebed in de reguliere beheer web interface. Dat moet je dus eerst mogelijk maken.

Voer deze stappen uit op de IR1101 om IOx en de webinterface in te schakelen.

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

De laatste regel voegt een gebruiker met 15 rechten toe. Deze gebruiker heeft toegang tot de webinterface en IOx lokale manager.

2. IOx-netwerken configureren

Voordat u toegang tot de web interface, laten we de vereiste configuratie voor het IOx netwerk toevoegen. Achtergrondinformatie is te vinden in de IR1101-documentatie voor IOx: https://www.cisco.com/c/en/us/td/docs/routers/access/1101/software/configuration/guide/b-cisco-ir1101-scg.html

Kortom, de IOx applicaties kunnen communiceren met de buitenwereld met behulp van de VirtualPortGroup0 interface (vergelijkbaar met de Gi2 op IR809 en Gi5 op IR829 interfaces).

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

Aangezien u de VirtualPortGroup0-interface als Network Address Translation (NAT) binnen vormt, moet u de ip Nat-buitenverklaring op de Gi 0/0/0-interface toevoegen om communicatie van en naar de IOx-toepassingen met het gebruik van NAT mogelijk te maken:

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

Om toegang tot poort 9000 voor de container, die u kunt geven 192.168.1.15, moet u een poort voorwaarts toevoegen:

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

Gebruik voor deze handleiding statisch geconfigureerde IP's per IOSx-toepassing. Als u IP-adressen dynamisch aan de toepassingen wilt toewijzen, moet u de configuratie voor een DHCP-server toevoegen in het subnetbestand van VirtualPortGroup0.

Deel 3. Access Local Manager en de IOSx-toepassing implementeren

Nadat u deze lijnen aan de configuratie hebt toegevoegd, kunt u de IR1101 openen met behulp van de webinterface. Navigeer naar het Gi 0/0/0 IP-adres met het gebruik van uw browser zoals getoond in de afbeelding.

Gebruik de privilege 15-account die in Stap 1 is gemaakt om in te loggen op de webinterface en te navigeren naar Configuration - IOx zoals in de afbeelding.

Gebruik in de inlognaam van IOx Local Manager dezelfde account om door te gaan zoals in de afbeelding.

Klik op Add New, selecteer een naam voor de IOx-toepassing en kies het pakket.tar dat in deel 1 is gebouwd zoals in de afbeelding.

Wanneer het pakket is geüpload, kunt u het activeren zoals in de afbeelding.

In het tabblad Resources opent u de interface-instelling om het vaste IP te specificeren dat u wilt toewijzen aan de app zoals in de afbeelding.

Klik op OK en vervolgens op Activeren. Nadat de actie is voltooid, gaat u terug naar de pagina Local Manager (Toepassingen in het bovenste menu) en start u de toepassing zoals in de afbeelding.

Nadat u deze stappen hebt doorlopen, wordt uw applicatie uitgevoerd en is beschikbaar via poort 9000 met het gebruik van de Gi 0/0/0 interface van de IR1101.

Verifiëren

Gebruik deze sectie om te controleren of uw configuratie goed werkt.

Om te verifiëren, kunt u toegang tot het IP-adres van de Gi 0/0/0 interface op de IR1101 met het gebruik van poort 9000.

Als alles goed gaat, toont dit, zoals het is gemaakt in het Python-script.

Problemen oplossen

Deze sectie bevat informatie die u kunt gebruiken om problemen met de configuratie te troubleshooten.

Om problemen op te lossen, kunt u het logbestand dat u in het Python-script maakt controleren met behulp van een lokale manager.

Navigeer naar Toepassingen, klik op Beheer op de iox_web applicatie en selecteer vervolgens het tabblad Logs zoals in de afbeelding.