Creación e implementación de un paquete Docker IOx para la arquitectura IR1101 ARM

Introducción

Este documento describe cómo preparar, construir e implementar un paquete IOx basado en Docker para el gateway de Internet of Things (IoT) basado en ARM IR1101.

Prerequisites

Requirements

Cisco recomienda que tenga conocimiento sobre estos temas:

• Linux
• Contenedores
• IOx

Componentes Utilizados

La información que contiene este documento se basa en las siguientes versiones de software y hardware.

• IR1101 accesible a través de Secure Shell (SSH)
  
  • Dirección IP configurada
  • Acceso al dispositivo con privilegios 15 usuarios
• Linux host (una instalación mínima de Debian 9 (elástico) se utiliza para este artículo)
• Archivos de instalación del cliente IOx que se pueden descargar de: https://software.cisco.com/download/release.html?mdfid=286306005&softwareid=286306762

La información que contiene este documento se creó a partir de los dispositivos en un ambiente de laboratorio específico. Todos los dispositivos que se utilizan en este documento se pusieron en funcionamiento con una configuración verificada (predeterminada). If your network is live, make sure that you understand the potential impact of any command.

Antecedentes

El IR1101 es un poco diferente en comparación con la mayoría de las otras plataformas IOx, ya que se basan principalmente en x86. El IR1101 se basa en la arquitectura ARM64v8, por lo que no es posible implementar contenedores o paquetes IOx creados para x86 directamente en la plataforma. Este documento comienza desde cero y prepara el entorno para la construcción de contenedores Docker basados en ARM64v8 y explica cómo construir, empaquetar e implementar en el IR1101 con el uso de un PC x86.

Como ejemplo, se utiliza un script Python muy pequeño que es un servidor web simple y se crea un contenedor Docker alrededor para empaquetarlo eventualmente para que se ejecute en el IR1101. Lo único que hace el servidor web es escuchar en un puerto predefinido (9000) y devolver una página simple cuando recibe una solicitud GET. Esto le permite probar la capacidad de ejecutar su propio código y probar el acceso de red a la aplicación IOx una vez que comienza a ejecutarse.

El paquete es construido por las herramientas Docker, con el uso de Alpine Linux. Alpine Linux es una pequeña imagen de Linux (alrededor de 5MB), que a menudo se utiliza como base para contenedores Docker.

Dado que la mayoría de los equipos de sobremesa/portátiles/VM de los alrededores están basados en x86, debe emular la arquitectura ARM64v8 en la máquina basada en x86 en la que está construido el contenedor. Puede hacerlo fácilmente con el uso de la emulación de usuario de Quick Emulator (QEMU). Esto permite la ejecución de ejecutables en una arquitectura no nativa del mismo modo que se ejecutaría en su arquitectura nativa.

Configurar

Parte 1. Creación del paquete IOx para IR1101

1. Instalar y preparar el cliente IOx en el host Linux

Usted necesita ioxclient para empaquetar el contenedor Docker como un paquete IOx una vez que está construido, así que preparemos esto primero.

Primero copie o descargue el paquete ioxclient. Se encuentra disponible en: 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

Extraiga el envase:

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

Agregue la ruta de acceso a la variable PATH para que esté disponible sin el uso de la ubicación completa. Si reinicia el equipo o cambia de usuario, no olvide repetir este paso:

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

Inicie ioxclient por primera vez para crear un perfil obligatorio. Dado que sólo utiliza ioxclient para empaquetar el contenedor Docker, los valores se pueden dejar como predeterminados:

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. Instalar y preparar el entorno Docker en la máquina de compilación de Linux

Este Docker se utiliza para crear un contenedor a partir de la imagen base de Alpine e incluir los archivos necesarios para el caso práctico. Los pasos dados se basan en las guías de instalación oficiales de Docker Community Edition (CE) para Debian: https://docs.docker.com/install/linux/docker-ce/debian/

Actualice las listas de paquetes en su máquina:

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

Instale las dependencias para utilizar el repositorio Docker:

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

Agregue la clave GPG (Docker GNU Privacy Guard) como una clave GPG válida:

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

Verifique la huella digital de la clave GPG instalada:

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]

Agregue el repositorio estable de Docker:

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

Actualice las listas de paquetes de nuevo a medida que agrega el repositorio Docker:

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

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

Para poder acceder/ejecutar Docker como usuario normal, agregue este usuario al grupo Docker y actualice la pertenencia al grupo:

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

3. Instale los paquetes de emulación de usuario de QEMU

Después de haber instalado Docker, debe instalar los emuladores de usuario de QEMU. Utilice el emulador QEMU vinculado estáticamente desde el contenedor Docker para que pueda ejecutar el contenedor para ARM64v8 en nuestra máquina Linux basada en x86, aunque el contenedor de destino está diseñado para la arquitectura ARM64v8.

Instale los paquetes:

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

Después de la instalación, estos son los emuladores QEMU enlazados estáticamente disponibles en /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
...

El primero de la lista, es el que necesita: arch64 es el nombre del arco para ARM64v8 para Linux.

4. Pruebe si un contenedor arch64/ARV64v8 se ejecuta en una máquina Linux x86

Ahora que tiene instalado Docker y los binarios QEMU necesarios, puede probar si puede ejecutar un contenedor Docker creado para ARM64v8 en la máquina x86:

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

Como puede ver en el resultado, se obtiene el contenedor arm64v8 Alpine y se hace funcionar con acceso al emulador. 

Si solicita la arquitectura del contenedor, puede ver que el código está compilado para arch64. Exactamente como el arco de destino para el contenedor debe ser para IR1101.

5. Preparar archivos para construir el contenedor de Docker Webserver

Ahora que se ha hecho toda la preparación, puede seguir adelante y crear los archivos necesarios para el contenedor del servidor web que debe ejecutarse en IR1101.

El primer archivo es webserver.py, la secuencia de comandos de Python que desea ejecutar en el contenedor. Como esto es sólo un ejemplo, obviamente, reemplace esto con el código real para ejecutar en su aplicación IOx:

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

Este código contiene la lógica para escribir en un archivo de registro, que está disponible para consulta en el Administrador local.

El segundo archivo necesario es el archivo Dockerfile. Esto define cómo se construye el contenedor:

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

El archivo Dockerdefine cómo se genera el contenedor. Comience desde la imagen base de Apline para ARM64v8, copie el emulador en el contenedor, ejecute el apk para agregar el paquete Python y copie el script del servidor web en el contenedor.

La última preparación que se necesita antes de poder construir el contenedor es copiar qemu-arch64-static al directorio desde donde se construye el contenedor:

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

6. Construir el contenedor Docker

Ahora que se ha hecho toda la preparación, puede construir el contenedor con el uso del archivo 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

Como prueba, ejecute el contenedor que acaba de crear y compruebe si la secuencia de comandos funciona:

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

Como puede ver en este resultado, la arquitectura del contenedor es el arch64 de destino. Después de iniciar el script, verá que escucha las solicitudes en el puerto 9000.

 7. Crear el paquete IOx

El contenedor está listo para ser empaquetado. Antes de que pueda pedirle a ioxclient que haga esto, primero debe crear el descriptor de paquete: package.yaml.

Este archivo describe el aspecto del paquete, cuántos recursos necesita ejecutar y qué debe iniciar.

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

Como puede ver, la arquitectura de la CPU está establecida en arch64. Para obtener acceso al puerto TCP 9000, utilice rootfs.tar como los rootfs y al inicio, puede ejecutar python/webserver.py.

Lo último que debe hacer antes de poder empaquetar es extraer el archivo rootfs.tar del contenedor Docker:

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

En este punto, puede utilizar ioxclient para construir el paquete IOx para IR1101:

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

Ahora mismo, hay un paquete para implementar en el IR1101 listo como package.tar. En la siguiente parte se explica cómo preparar el dispositivo para la implementación.

Parte 2. Configuración del IR1101 para IOx

1. Habilite la interfaz web, IOx y el Administrador local

Local Manager es una GUI para implementar, activar, iniciar, administrar y resolver problemas de aplicaciones IOx. Para IR1101, está integrado en la interfaz web de gestión normal. Por lo tanto, primero debe habilitarlo.

Realice estos pasos en el IR1101 para habilitar IOx y la interfaz web.

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

La última línea agrega un usuario con 15 permisos de privilegio. Este usuario tiene acceso a la interfaz web y al administrador local de IOSx.

2. Configuración de redes IOx

Antes de acceder a la interfaz web, agreguemos la configuración necesaria para la red IOx. Puede encontrar información general en la documentación del IR1101 para IOx: https://www.cisco.com/c/en/us/td/docs/routers/access/1101/software/configuration/guide/b-cisco-ir1101-scg.html

En resumen, las aplicaciones IOx pueden comunicarse con el mundo exterior mediante la interfaz VirtualPortGroup0 (comparable con la interfaz Gi2 en IR809 y la interfaz Gi5 en IR829).

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

Al configurar la interfaz VirtualPortGroup0 como traducción de direcciones de red (NAT) interna, debe agregar la instrucción ip nat outside en la interfaz Gi 0/0/0 para permitir la comunicación hacia y desde las aplicaciones IOx con el uso de NAT:

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

Para permitir el acceso al puerto 9000 para el contenedor, que puede dar 192.168.1.15, debe agregar un puerto hacia adelante:

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

Para esta guía, utilice IP configuradas estáticamente por aplicación IOx. Si desea asignar direcciones IP dinámicamente a las aplicaciones, debe agregar la configuración para un servidor DHCP en la subred de VirtualPortGroup0.

Parte 3. Acceder a Local Manager e implementar la aplicación IOx

Después de agregar estas líneas a la configuración, puede acceder al IR1101 con el uso de la interfaz web. Navegue hasta la dirección IP Gi 0/0/0 con el uso de su navegador como se muestra en la imagen.

Utilice la cuenta de privilegio 15 creada en el Paso 1. para iniciar sesión en la interfaz web y navegar hasta Configuration - IOx como se muestra en la imagen.

En el inicio de sesión de IOx Local Manager, utilice la misma cuenta para continuar como se muestra en la imagen.

Haga clic en Add New, seleccione un nombre para la aplicación IOx y elija el package.tar que se construyó en la Parte 1 como se muestra en la imagen.

Una vez cargado el paquete, puede activarlo como se muestra en la imagen.

En la pestaña Resources, abra la configuración de la interfaz para especificar la IP fija que desea asignar a la aplicación como se muestra en la imagen.

Haga clic en Aceptar, luego en Activar. Una vez finalizada la acción, vuelva a la página principal de Local Manager (botón Applications en el menú superior) y, a continuación, inicie la aplicación como se muestra en la imagen.

Después de seguir estos pasos, la aplicación se ejecuta y está disponible a través del puerto 9000 con el uso de la interfaz Gi 0/0/0 del IR1101.

Verificación

Utilize esta sección para confirmar que su configuración funcione correctamente.

Para verificar, puede acceder a la dirección IP de la interfaz Gi 0/0/0 en el IR1101 con el uso del puerto 9000.

Si todo va bien, esto se muestra, como se creó en el script Python.

Troubleshoot

En esta sección se brinda información que puede utilizar para resolver problemas en su configuración.

Para resolver problemas, puede verificar el archivo de registro que crea en el script Python con el uso de un administrador local.

Navegue hasta Aplicaciones, haga clic en Administrar en la aplicación iox_web, luego seleccione la pestaña Registros como se muestra en la imagen.