Desarrollo de una aplicación de JavaScript para Cosmos DB con SQL API

Para crear o usar Cosmos DB con SQL API, use un recurso de Cosmos DB. Aprenda a crear el recurso de Cosmos DB y a usar la base de datos.

Desarrollo local con el emulador de CosmosDB

Obtenga información sobre cómo instalar el emulador de CosmosDB e iniciar el emulador para el desarrollo con SQL API.

Creación de un recurso de Cosmos DB para una base de datos de SQL API

Puede crear un recurso con:

Creación de un recurso de Cosmos DB para SQL API

Use el siguiente comando az cosmosdb create de la CLI de Azure en Azure Cloud Shell para crear un nuevo recurso de Cosmos DB. Este comando puede tardar un par de minutos en completarse.

az cosmosdb create \
--subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
--resource-group YOUR-RESOURCE-GROUP \
--name YOUR-RESOURCE-NAME \
--kind YOUR-DB-KIND \
--ip-range-filter YOUR-CLIENT-IP

Para habilitar el acceso del firewall desde el equipo local al recurso, reemplace 123.123.123.123 por su propia dirección IP del cliente. Para configurar varias direcciones IP, use una lista separada por comas.

Adición de una regla de firewall para la dirección IP del cliente

Use este procedimiento si necesita agregar una dirección IP de cliente al recurso una vez creado para que la conexión del cliente con el servidor de JavaScript se realice correctamente. Use el comando az cosmosdb update para actualizar las reglas de firewall.

az cosmosdb update \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --ip-range-filter 123.123.123.123

Para configurar varias direcciones IP, use una lista separada por comas.

az cosmosdb update \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE_NAME \
    --ip-range-filter 123.123.123.123,456.456.456.456

Obtención de las claves de Cosmos DB para el recurso

Recupere las claves para la instancia con el comando az cosmosdb keys list:

az cosmosdb keys list \
    --subscription YOUR-SUBSCRIPTION-ID-OR-NAME \
    --resource-group YOUR-RESOURCE-GROUP \
    --name YOUR-RESOURCE-NAME

Esto devuelve cuatro claves, dos de lectura y escritura y dos de solo lectura. Como hay dos, puede proporcionar una clave a dos sistemas o desarrolladores diferentes, para su uso y reciclado de forma individual.

Consulta y uso de la base de datos de SQL API en Azure Cosmos DB

Al desarrollar la base de datos de SQL API con JavaScript, use el Explorador de Cosmos para trabajar con la base de datos.

Use el explorador Cosmos, que se encuentra en  , para ver y trabajar con la base de datos.

El Explorador de Cosmos también está disponible en Azure Portal para el recurso como Explorador de datos.

Uso @azure/COSMOS SDK para conectarse a la base de datos

Conéctese a la base de datos de Azure Cosmos DB con SQL API mediante el siguiente SDK de Azure:

Para conectarse y usar SQL API en Azure Cosmos DB con JavaScript, use el procedimiento siguiente.

  1. Asegúrese de que Node.js y npm están instalados.

  2. Cree un proyecto de Node.js en una carpeta nueva:

    mkdir dataDemo && \
        cd dataDemo && \
        npm init -y && \
        npm install @azure/cosmos && \
        touch index.js && \
        code .
    

    Este comando:

    • crea una carpeta de proyecto llamada dataDemo.
    • cambia el terminal de Bash a esa carpeta.
    • inicializa el proyecto, lo que crea el archivo package.json.
    • crea el archivo de script index.js.
    • abre el proyecto en Visual Studio Code.
  3. Copie el siguiente código JavaScript en el archivo index.js:

    const CosmosClient = require("@azure/cosmos").CosmosClient;
    
    // CHANGE THESE VALUES
    const COSMOS_DB_RESOURCE_NAME = "YOUR-RESOURCE-NAME";
    const COSMOS_DB_RESOURCE_KEY = "YOUR-RESOURCE-KEY";
    
    let client = null;      // Cosmos DB SQL API connection object
    let db = null;          // DB object
    let container = null;   // Container object
    
    // data
    const DATABASE_DOCS = [
        { name: "Joe", job: "banking" },
        { name: "Jack", job: "security" },
        { name: "Jill", job: "pilot" }];
    
    const ALL_DOCS = null;
    
    // Azure Cosmos DB config
    const config = {
        COSMOSDB_SQL_API_URI: `https://${COSMOS_DB_RESOURCE_NAME}.documents.azure.com:443/`,
        COSMOSDB_SQL_API_KEY: COSMOS_DB_RESOURCE_KEY,
        COSMOSDB_SQL_API_DATABASE_NAME: "DemoDb",
        COSMOSDB_SQL_API_CONTAINER_NAME: "DemoContainer"
    }
    
    // Unique Id = Guid
    const newGuid = () => {
        const s4 = () => Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
        return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4() + s4() + s4()}`;
    }
    
    // insert array
    const insert = async (newItems) => {
    
        const results = [];
        for (const item of newItems) {
    
            item.id = newGuid();
            const result = await container.items.create(item);
            results.push(result.item);
        }
        return results;
    };
    // find all or by id
    const find = async (query) => {
    
        if (query == null) {
            query = "SELECT * from c"
        } else {
            query = `SELECT * from c where c.id = ${query}`
        }
    
        const result = await container.items
            .query(query)
            .fetchAll();
    
        return result && result.resources ? result.resources : [];
    }
    // remove all or by id
    const remove = async (id) => {
    
        // remove 1
        if (id) {
            await container.item(id).delete();
        } else {
    
            // get all items
            const items = await find();
    
            // remove all
            for await (const item of items) {
                await container.item(item.id).delete();
            }
        }
    
        return;
    }
    // connection with SDK
    const connect = () => {
        try {
    
            const connectToCosmosDB = {
                endpoint: config.COSMOSDB_SQL_API_URI,
                key: config.COSMOSDB_SQL_API_KEY
            }
    
            return new CosmosClient(connectToCosmosDB);
    
        } catch (err) {
            console.log('Cosmos DB SQL API - can\'t connected - err');
            console.log(err);
        }
    }
    const connectToDatabase = async () => {
    
        client = connect();
    
        if (client) {
    
            // get DB
            const databaseResult = await client.databases.createIfNotExists({ id: config.COSMOSDB_SQL_API_DATABASE_NAME });
            db = databaseResult.database;
    
            if (db) {
                // get Container
                const containerResult = await db.containers.createIfNotExists({ id: config.COSMOSDB_SQL_API_CONTAINER_NAME });
                container = containerResult.container;
                return !!db;
            }
        } else {
            throw new Error("can't connect to database");
        }
    
    
    }
    
    // use Database
    const dbProcess = async (docs) => {
    
        // connect
        const db = await connectToDatabase();
        if (!db) throw Error("db not working")
        console.log("connected to " + config.COSMOSDB_SQL_API_DATABASE_NAME + "/" + config.COSMOSDB_SQL_API_CONTAINER_NAME)
    
        // insert new docs
        const insertResult = await insert(docs);
        console.log("inserted " + insertResult.length)
    
        // get all docs
        const findResult = await find(ALL_DOCS);
        console.log("found " + findResult.length);
    
        // remove all then make sure they are gone
        await remove(ALL_DOCS);
        const findResult3 = await find(ALL_DOCS);
        console.log("removed all, now have " + findResult3.length);
    
        return;
    
    }
    
    dbProcess(DATABASE_DOCS)
    .then(() => {
        console.log("done")
    }).catch(err => {
        console.log(err)
    })
    
  4. Reemplace las siguientes variables del script:

    • YOUR-RESOURCE-NAME: el nombre que usó al crear el recurso de Cosmos DB
    • YOUR-RESOURCE-KEY: una de las claves de lectura y escritura del recurso
  5. Ejecute el script.

    node index.js
    

    Los resultados son:

    connected to DemoDb/DemoContainer4
    inserted 3
    found 3
    removed all, now have 0
    done
    

Pasos siguientes