Ejercicio: Creación de una cuenta de almacenamiento e implementación de cámaras virtuales

10 minutos

En esta unidad, creará una cuenta de Azure Storage y, después, implementará una serie de cámaras simuladas en Node.js que cargará fotografías de la fauna en la cuenta de almacenamiento. La cuenta de almacenamiento almacenará fotografías tomadas por las cámaras que implemente.

La creación de una cuenta de almacenamiento y la carga de fotografías de la fauna en la cuenta son los primeros pasos para crear una solución de un extremo a otro que muestre cómo se pueden combinar los servicios de Azure para crear sistemas sofisticados que incorporen servicios en la nube e inteligencia artificial.

Creación de una cuenta de almacenamiento

Comencemos usando Azure Cloud Shell para crear una cuenta de Azure Storage. Cloud Shell proporciona una línea de comandos basada en el explorador que puede usar para ejecutar comandos de Azure. Cloud Shell es una alternativa a la instalación de la CLI de Azure en un equipo propio.

Nota:

El uso de la CLI o de Cloud Shell suele ser una cuestión de preferencias personales. Una de las ventajas de Cloud Shell es que no requiere la instalación de software. Otra ventaja es que no tiene que actualizar Cloud Shell periódicamente como sucede con la CLI.

En el explorador, vaya a Azure Portal. Si se le pide que inicie sesión, hágalo con la cuenta de Microsoft.
En los controles globales del portal, seleccione Azure Cloud Shell.

Apertura de Azure Cloud Shell

Si se le solicita que elija un lenguaje de programación, seleccione Bash. Si se le pide que permita a Cloud Shell crear una cuenta de almacenamiento (no se monta ningún almacenamiento), elija la opción de crear un almacenamiento nuevo. Cloud Shell montará el nuevo almacenamiento y, después, abrirá la ventana del símbolo del sistema. Verá un mensaje de bienvenida y luego el símbolo del sistema.

También puede abrir Cloud Shell si va a https://shell.Azure.com en una ventana independiente del explorador.
La tarea siguiente consiste en crear un grupo de recursos que contenga la cuenta de almacenamiento y otros recursos de Azure que componen la solución. Asegúrese de que el lenguaje seleccionado en Cloud Shell es Bash. Después, cree un grupo de recursos denominado polar-bear-rg en la región de Azure Centro-sur de EE. UU.:
```
az group create --name polar-bear-rg --location southcentralus
```
Para pegar comandos en Cloud Shell, presione Mayús+Insertar. Para copiar texto de Cloud Shell en el Portapapeles, presione Ctrl+Insertar.
Ejecute el comando siguiente para guardar el nombre que quiera usar para la cuenta de almacenamiento. En el comando, reemplace <account-name> por el nombre que quiera usar. Podrá hacer referencia al nombre de la cuenta más adelante en el campo $ACCOUNT_NAME.
```
ACCOUNT_NAME="<account-name>"
```
Nota:

Los nombres de las cuentas de almacenamiento deben tener entre 3 y 24 caracteres, y solo pueden incluir números y letras en minúscula. El nombre de la cuenta debe ser único en Azure. Si se produce un error en un comando porque el nombre de la cuenta de almacenamiento ya está en uso, cámbielo y vuelva a intentarlo.

Ejecute el comando siguiente para crear una cuenta de almacenamiento en el grupo de recursos polar-bear-rg:

az storage account create --name $ACCOUNT_NAME --resource-group polar-bear-rg --location southcentralus --sku Standard_LRS

Las cuentas de Azure Storage admiten cuatro tipos de almacenamiento: blobs, tablas, archivos y colas. Azure Blob Storage proporciona un almacén de objetos que se puede escalar de forma masiva para datos de texto y binarios. Las fotografías que se carguen en la cuenta de almacenamiento se almacenan como blobs. Para poder cargar blobs en una cuenta de almacenamiento, debe crear un contenedor para conservarlos.

Use el comando siguiente para crear un contenedor denominado photos en la cuenta de almacenamiento:
```
az storage container create --name photos --account-name $ACCOUNT_NAME
```
En Cloud Shell, ejecute el comando siguiente para enumerar las claves de acceso para la cuenta de almacenamiento:
```
az storage account keys list --account-name $ACCOUNT_NAME
```
La clave de acceso principal es el valor de propiedad key1, que contiene una serie larga de letras y números. Copie la clave de acceso principal de la salida y péguela en un archivo de texto para poder recuperarla más adelante.

Recuerde que puede presionar Ctrl+Insert para copiar texto de Cloud Shell en el Portapapeles.

Ahora tiene una cuenta de almacenamiento para almacenar fotografías y un contenedor en el que conservarlas. A continuación se implementarán algunas cámaras para tomar fotografías de la fauna y cargarlas en el almacenamiento de blobs.

Implementación de una matriz de cámara simulada

La tarea siguiente consiste en crear una aplicación de Node.js que simule una serie de cámaras con sensores de movimiento. Las cámaras cargan las fotografías tomadas de la fauna en el contenedor photos de la cuenta de almacenamiento.

Si Node.js no está instalado en el equipo, vaya a https://node.js.org/ e instálelo ahora. Para comprobar si Node.js está instalado y su versión, ejecute este comando en un símbolo del sistema o en una ventana de terminal:
```
node -v
```
Si Node.js está instalado, en la salida se muestra el número de versión. Si el número de versión es inferior a 8.0, descargue e instale la versión más reciente.
Cree un directorio en el disco duro para que sea el directorio del proyecto. Después, en el símbolo del sistema, ejecute cd para cambiar a ese directorio.
Ejecute el comando siguiente para inicializar el directorio del proyecto a fin de hospedar un proyecto de Node.js e instalar un paquete:
```
npm init -y
npm install azure-storage --save
```
El paquete azure-storage proporciona una interfaz programática para Azure Storage, incluido Blob Storage, para las aplicaciones de Node.js.
Cuando finalice la instalación, cree un subdirectorio denominado photos en el directorio del proyecto. Descargue un archivo ZIP de imágenes de las cámaras. Descomprima el archivo y, después, copie los 30 archivos .JPG del archivo .zip en el subdirectorio photos. Las cámaras simuladas cargan estas imágenes en Blob Storage.

Las imágenes siguientes son un ejemplo de las que se incluyen en el conjunto de datos. En la fauna que se muestra en las imágenes hay zorros árticos, osos polares y morsas.

En el directorio del proyecto, use Visual Studio Code para crear un archivo denominado cameras.json. Pegue el código JSON siguiente en el archivo:

[
    {
        "deviceId" : "polar_cam_0001",
        "latitude" : 75.401451,
        "longitude" : -95.722518
    },
    {
        "deviceId" : "polar_cam_0002",
        "latitude" : 75.027715,
        "longitude" : -96.041859
    },
    {
        "deviceId" : "polar_cam_0003",
        "latitude" : 74.996653,
        "longitude" : -96.601780
    },
    {
        "deviceId" : "polar_cam_0004",
        "latitude" : 75.247701,
        "longitude" : -96.074436
    },
    {
        "deviceId" : "polar_cam_0005",
        "latitude" : 75.044926,
        "longitude" : -93.651951
    },
    {
        "deviceId" : "polar_cam_0006",
        "latitude" : 75.601571,
        "longitude" : -95.294407
    },
    {
        "deviceId" : "polar_cam_0007",
        "latitude" : 74.763102,
        "longitude" : -95.091160
    },
    {
        "deviceId" : "polar_cam_0008",
        "latitude" : 75.473988,
        "longitude" : -94.069432
    },
    {
        "deviceId" : "polar_cam_0009",
        "latitude" : 75.232307,
        "longitude" : -96.277683
    },
    {
        "deviceId" : "polar_cam_0010",
        "latitude" : 74.658811,
        "longitude" : -93.783787
    }
]

Este archivo define 10 cámaras virtuales que cargarán fotografías a Blob Storage. Cada instancia de cámara contiene un identificador de dispositivo, así como una latitud y una longitud que especifican la ubicación de la cámara.

Los valores de latitud y longitud se corresponden con puntos de la costa de la isla Cornwallis al norte de Canadá. Es uno de los mejores sitios en Canadá para avistar osos polares. La isla Cornwallis se ubica junto a la Isla de Bathurst, donde se encuentra el Polar Bear Pass National Wildlife Area.

En el directorio del proyecto, cree un archivo denominado run.js. Pegue el código siguiente en el archivo:

'use strict';

// Connect to the storage account
var storage = require('azure-storage');

var blobService = storage.createBlobService(
    process.env.ACCOUNT_NAME,
    process.env.ACCOUNT_KEY
);

// Load image file names and create an array of cameras
var fs = require('fs');

fs.readdir('photos', (err, files) => {
    var cameras = JSON.parse(fs.readFileSync('cameras.json', 'utf8')).map(
        camera => new Camera(
            camera.deviceId,
            camera.latitude,
            camera.longitude,
            blobService,
            files
        )
    );

    // Start the cameras
    cameras.forEach(camera => {
        camera.start();
    });
});

class Camera {
    constructor(id, latitude, longitude, blobService, files) {
        this._id = id;
        this._latitude = latitude;
        this._longitude = longitude;
        this._blobService = blobService;
        this._files = files.slice(0);
        this._interval = 300000;
    }

    start() {
        // Register the first callback
        setTimeout(this.timer, Math.random() * this._interval, this);
        console.log('Started ' + this._id);
    }

    timer(self) {
        // Randomly select a photo
        var index = Math.floor(Math.random() * self._files.length);
        var filename = self._files[index]

        // Define the metadata to be written to the blob
        var metadata = {
            'latitude': self._latitude,
            'longitude': self._longitude,
            'id': self._id
        };

        // Upload the blob
        self._blobService.createBlockBlobFromLocalFile('photos', filename, 'photos/' + filename, { 'metadata': metadata }, (err, result) => {
            if (!err) {
                console.log(self._id + ': Uploaded ' + filename);
            }
            else {
                console.log(self._id + ': Error uploading ' + filename);
            }
        });

        // Register the next callback
        setTimeout(self.timer, Math.random() * self._interval, self);
    }
}

Este código usa la compatibilidad de clases de ECMAScript 6 (ES6) para definir una clase denominada Camera. Después, crea 10 instancias de Camera y las inicia. Cada cámara usa un temporizador aleatorio que se activa una vez cada pocos minutos para cargar imágenes de la fauna en el contenedor photos de Blob Storage. Las imágenes se seleccionan de forma aleatoria de los archivos del subdirectorio photos del directorio del proyecto. Cada blob que se crea contiene metadatos que identifican la cámara que ha cargado la fotografía y la ubicación de la cámara.

Si usa Windows, ejecute los comandos siguientes para crear un par de variables de entorno. En el comando, reemplace STORAGE_ACCOUNT_NAME por el nombre de la cuenta de almacenamiento que ha creado antes y reemplace STORAGE_ACCOUNT_KEY por la clave de acceso de la cuenta de almacenamiento:
```
set ACCOUNT_NAME=STORAGE_ACCOUNT_NAME
set ACCOUNT_KEY=STORAGE_ACCOUNT_KEY
```
Si ejecuta Linux o macOS, o se produce un error de credenciales al ejecutar los comandos de Windows, use estos comandos en su lugar:
```
export ACCOUNT_NAME=STORAGE_ACCOUNT_NAME
export ACCOUNT_KEY=STORAGE_ACCOUNT_KEY
```
En tiempo de ejecución, run.js lee estas variables de entorno y después las usa para conectarse a la cuenta de almacenamiento. El almacenamiento de "secretos" como estos en variables de entorno es más seguro que insertarlos en el código fuente. Si ha cerrado el símbolo del sistema o la ventana de terminal en la que ha ejecutado estos comandos, tendrá que volver a ejecutarlos antes de ejecutar run.js.
Ejecute el código siguiente para ejecutar run.js:
```
node run.js
```

Confirme que ve una salida similar a la del ejemplo siguiente. La salida indica que se ejecutan las 10 cámaras:

Started polar_cam_0001
Started polar_cam_0002
Started polar_cam_0003
Started polar_cam_0004
Started polar_cam_0005
Started polar_cam_0006
Started polar_cam_0007
Started polar_cam_0008
Started polar_cam_0009
Started polar_cam_0010

Durante el siguiente minuto o dos, confirme que ve una salida similar a la del ejemplo siguiente. Cada línea se corresponde a una fotografía cargada en Blob Storage por una de las cámaras virtuales:
```
polar_cam_0001: Uploaded image_19.jpg
polar_cam_0005: Uploaded image_26.jpg
polar_cam_0003: Uploaded image_11.jpg
```
Como run.js usa un generador de números aleatorios para decidir qué fotografías cargar y cuándo cargarlas, los resultados serán distintos a los mostrados en el ejemplo anterior.
Deje que run.js se ejecute hasta que se hayan cargado tres o más blobs. Después, vuelva al símbolo del sistema o la ventana de terminal en la que se ejecuta run.js y presione Ctrl+C para detenerlo.
En el explorador, vaya a Azure Portal. Abra la cuenta de almacenamiento que ha creado antes y, después, abra el contenedor photos. Confirme que el contenedor tiene varias imágenes .JPG, como se muestra en este ejemplo:

Imágenes cargadas en el contenedor photos
Seleccione uno de los blobs para mostrar un detalle de blob y examinar sus metadatos. Confirme que los metadatos del blob contienen propiedades denominadas latitude, longitude y id:

Visualización de metadatos del blob
Abra un blob para ver la imagen real:
- Seleccione los puntos suspensivos (...) y, después, Ver>Editar. Repita esta acción para ver las imágenes de varios blobs.
¿Qué imágenes contienen osos polares y cuáles no?

Continuar

Ejercicio: Creación de una cuenta de almacenamiento e implementación de cámaras virtuales

Creación de una cuenta de almacenamiento

Implementación de una matriz de cámara simulada

Comentarios