Implementar aplicaciones Node.js en Google App Engine

Introducción

TL; DR; En este artículo vamos a implementar una aplicación Node.js en Google App Engine y en el proceso veremos cómo se hace.

Esta será una demostración paso a paso desde la configuración de nuestro entorno de Google App Engine hasta la implementación.

nótese bien: Este tutorial requiere un conocimiento básico de JavaScript, Node.js, MongoDB, NPM y Express.js.

Puede obtener el código fuente de la aplicación terminada aquí.

¿Qué es Google App Engine?

Google App Engine, una plataforma de computación en la nube (PaaS) lanzada por Google el 7 de abril de 2008, está escrita en C ++, PHP, Node.js y Python.

Google App Engine proporciona un entorno ideal para que los desarrolladores y las organizaciones alojen sus aplicaciones sin tener que pensar en la infraestructura, el tiempo de inactividad o la ampliación a mil millones de usuarios. Google App Engine proporciona todo esto y, en realidad, no debe preocuparse por el servidor, simplemente implemente y Google App Engine se encargará de casi todo lo demás. Google App Engine escalará y asignará automáticamente más recursos a su aplicación cuando las solicitudes y la demanda sean enormes.

Google App Engine es un entorno de ejecución en la nube que le permite implementar y ejecutar fácilmente aplicaciones web estándar. Proporciona las herramientas para monitorear, escalar y equilibrar la carga de la infraestructura, para que pueda concentrarse en crear sus aplicaciones web en lugar de los servidores que las ejecutan.

Cree una instancia de Google App Engine (Instancia de 2.a generación)

Para comenzar a usar Google App Engine, vamos a configurar un proyecto de Google Cloud Platform:

• Registrarse a su cuenta de Google. Si aún no tiene uno, debería Regístrate.
• Ve a la App Engine sitio web
• Puede parecer un diálogo que exige el uso de la versión de la aplicación de Google Cloud Console: «Usar la aplicación» o «Ahora no». Depende de usted hacer su elección, pero preferiblemente, haga clic en «Ahora no» para continuar.
• En la pantalla que aparece presentará dos opciones: «Crear» o «Seleccionar». Para este tutorial, estamos creando un nuevo proyecto, haga clic en el botón «Crear». Si superó el número máximo de su cuota de proyectos de GCP, debe «Seleccionar» un proyecto.
• Escribe el nombre de tu proyecto en el campo de texto «Nombre del proyecto», debajo del campo de texto estará tu ID de proyecto generado por GCP según el nombre de tu proyecto. haga clic en el botón «Crear» cuando haya terminado.
• Después de unos segundos, aparece una pantalla para «Seleccionar una ubicación». En el widget desplegable «Seleccionar una región», haga clic en él para seleccionar su región preferida, luego haga clic en «Siguiente».
• La siguiente pantalla muestra «Habilitar facturación». Haga clic en «Configurar facturación».
• Aparece un diálogo modal, haga clic en «Crear cuenta de facturación».
• Escriba el nombre de su cuenta de facturación preferida en la siguiente ventana o puede ir con el nombre predeterminado.
• Seleccione su país, USD ha sido seleccionado como moneda predeterminada, haga clic en el botón «Confirmar».
• En la siguiente ventana, complete sus datos, tanto los datos personales como los de su cuenta bancaria
• Haga clic en el botón «Enviar y habilitar facturación». Ahora, hemos creado un proyecto de Google Cloud con la facturación habilitada.

¡Ya hemos terminado!

Instalación de Google Cloud Tools (Cloud SDK)

Las herramientas de Google Cloud son una bolsa llena de utilidades que son muy útiles para configurar y acceder a los productos de Google Cloud: Google Kubernetes, Google App Engine, Google Big Query desde su terminal. Para comenzar a instalar el SDK de Cloud, vaya a SDK de Google Cloudy descargue el instalador del SDK para su sistema operativo.

El SDK de Google Cloud contiene herramientas como gcloudy gsutil, pero usaremos el gcloud herramienta para inicializar e implementar nuestra aplicación.

Te puede interesar:Agrupación de K-medias con Scikit-Learn

los gcloud La herramienta contiene varios comandos para permitir a los usuarios realizar diferentes acciones en un proyecto de Google Cloud:

• información de gcloud: Muestra información sobre su SDK de Cloud, su sistema, el usuario que inició sesión y el proyecto actualmente activo.
• lista de autenticación de gcloud: Muestra la lista de cuentas de Google activas en el SDK de Cloud.
• gcloud init: inicializa un proyecto en la nube de Google.
• ayuda de gcloud: Muestra los comandos disponibles en gcloud y su uso.
• lista de configuración de gcloud Muestra la lista de gcloud configuraciones.

Bien, hemos divagado un poco, volvamos a lo que tenemos entre manos, después de descargar el instalador del SDK de Cloud, inicie el instalador y siga las instrucciones, asegúrese de verificar las opciones relevantes presentadas. Una vez completada la instalación, el instalador iniciará el comando gcloud init en una ventana de terminal.

Este comando lo llevará a través de una serie de configuraciones. Le presentará una opción para iniciar sesión:

You must log in to continue. Would you like to log in (Y/n)?

Escriba «Y» y presione la tecla Enter. Lanzará su navegador web predeterminado, donde seleccionará su cuenta de Google preferida. Después de eso, se mostrará en la lista de terminales de sus proyectos de Google:

You are logged in as [YOUR_GOOGLE_ACCOUNT_EMAIL]:

pick cloud project to use:
 [1] [YOUR_PROJECT_NAME]
 [2] Create a new project
Please enter numeric choice or text value (must exactly match list item):

nótese bien: gcloud seleccionará automáticamente, si solo tiene un proyecto.

A continuación, se le solicita que elija una zona predeterminada de Compute Engine:

Which Google Compute Engine zone would you like to use project default:
 [1] asia-east1-a
 ...
 [16] us-east1-b
 ...
 [25] Do not select default zone
Please enter numeric choice or text value (must exactly match list item):

Después de seleccionar su zona predeterminada, gcloud realiza una serie de comprobaciones e imprime:

Your project default Compute Engine zone has been set to [YOUR_CHOICE_HERE]
You can change it by running [gcloud config set compute/zone NAME]

Your project default Compute Engine region has been set to [YOUR_CHOICE_HERE]
You can change it by running [gcloud config set compute/region NAME]

Su SDK de Google Cloud está configurado y listo para usar.

Configura nuestra aplicación Node.js

Ahora, nuestro proyecto de Google Cloud se ha configurado. Configuremos nuestra aplicación Node.js. Vamos a crear una API RESTful para la película Black Panther. Wooh !!! Esto será genial. El 16 de febrero de 2018, la primera película de superhéroes negros de Marvel se estrenó en los cines de todo el mundo, obteniendo una enorme recaudación de $ 903 millones en taquilla, al momento de escribir este artículo, convirtiéndola en la 45a película más taquillera de todos los tiempos y la película más taquillera. en 2018.

Construyamos una API que devolverá los personajes de Black Panther.

Punto final de API

• Personaje – Este recurso trata sobre los personajes de Black Panther.
  • POST – / blackpanther / Crea una nueva instancia de Black Panther.
  • OBTENER – / blackpanthers / Devuelve todos los personajes de Black Panther.
  • OBTENER – / blackpanther /<id> Devuelve el ID de personaje de Black Panther especificado.
  • PUT – / blackpanther /<id> Actualiza los atributos de un personaje de Black Panther.
  • BORRAR – / blackpanther /<id> Elimina un personaje de Black Panther.

Estructura del modelo de personaje de Black Panther

{
    "alias": String,
    "occupation": String,
    "gender": String,
    "place_of_birth": String,
    "abilities": String,
    "played_by": String,
    "image_path": String
}

Cree puntos finales de API para la API de Black Panther

Para comenzar, comencemos creando nuestra carpeta de proyecto, abra su terminal y ejecute el siguiente comando:

Te puede interesar:Guía para principiantes de ngrx y Angular

$ mkdir _nodejs_gae

Luego, muévete a la carpeta:

$ cd _nodejs_gae

La aplicación Node.js se inicializa con la npm init mando. Ahora, estamos dentro de la carpeta de nuestro proyecto, ejecute el siguiente comando para crear una instancia de una aplicación Node.js:

$ npm init -y

Este comando crea una aplicación Node.js con sus credenciales preconfiguradas. A estas alturas, su carpeta se verá así:

|- _nodejs_gae
    |- package.json

Para seguir las mejores prácticas, vamos a dividir nuestra aplicación en controladores, modelos y rutas. Sí, sé que es excesivo para esta aplicación de demostración, pero siempre es bueno hacerlo bien.

Vamos a crear nuestro index.js archivo (nuestro punto de entrada del servidor) – touch index.js

Cree las siguientes carpetas:

• mkdir routes
• mkdir ctrls
• mkdir models

Ahora tenemos routes, ctrlsy models carpetas.

• rutas: Contendrá todas las rutas definidas en nuestra API y llamará a la función del controlador asignada a la solicitud HTTP correspondiente.
• ctrls: Mantendrá la acción para obtener los datos solicitados de los modelos.
• modelos: Contendrá el modelo de base de datos de nuestra API.

Vamos a tener una ruta, un modelo y un controlador asociado con nuestra API. Ejecute los siguientes comandos para crear los archivos:

• touch routes/route.js
• touch ctrls/ctrl.js
• touch models/Character.js

Nuestra estructura de carpetas debería verse así ahora:

|- _nodejs_gae
    |- routes/
        |- route.js
    |- ctrls/
        |- ctrl.js
    |- models/
        |- Character.js
    |- index.js
    |- package.json

OK, instalemos nuestras dependencias:

• npm i express -S
• npm i mongoose -S
• npm i body-parser -S

Ahora, abrimos nuestro Character.js y pega el siguiente código en él:

Te puede interesar:Introducción a ELK Stack

const mongoose = require('mongoose')

let Character = new mongoose.Schema({
    alias: String,
    occupation: String,
    gender: String,
    place_of_birth: String,
    abilities: String,
    played_by: String,
    image_path: String
})
module.exports = mongoose.model('Character', Character)

Aquí, declaramos nuestro esquema de modelo Character utilizando mongoose Clase de esquema. Nuestro modelo se exportó para que podamos importar y usar el esquema en cualquier lugar de nuestra aplicación.

Ok, agreguemos código a nuestro ctrl.js archivo:

const Character = require('./../models/Character')

module.exports = {
    getCharacter: (req, res, next) => {
        Character.findById(req.params.id, (err, Character) => {
            if (err)
                res.send(err)
            else if (!Character)
                res.send(404)
            else
                res.send(Character)
            next()
        })
    },
    getAllCharacters: (req, res, next) => {
        Character.find((err, data) => {
            if (err) {
                res.send(err)
            } else {
                res.send(data)
            }
            next()
        })
    },
    deleteCharacter: (req, res, next) => {
        Character.findByIdAndRemove(req.params.id, (err) => {
            if (err)
                res.send(err)
            else
                res.sendStatus(204)
            next()
        })
    },
    addCharacter: (req, res, next) => {
        (new Character(req.body)).save((err, newCharacter) => {
            if (err)
                res.send(err)
            else if (!newCharacter)
                res.send(400)
            else
                res.send(newCharacter)
            next()
        })
    },
    updateCharacter: (req, res, next) => {
        Character.findByIdAndUpdate(req.params.id, req.body, (err, updatedCharacter) => {
            if (err)
                res.send(err)
            else if (!updatedCharacter)
                res.send(400)
            else
                res.send(req.body)
            next()
        })
    }
}

Aquí, declaró nuestro 4 CRUDy funciones: getCharacter, deleteCharacter, getAllCharacctersy updateCharacter. Como sus nombres implican, actúan CREATE, READ, UPDATE y DELETE acciones en nuestra API de Black Panther.

OK, abramos el route.js archivo y pegue el siguiente código en él:

const ctrl = require('./../ctrls/ctrl')

module.exports = (router) => {

    /** get all Black Panther characters */
    router
        .route('/blackpanthers')
        .get(ctrl.getAllCharacters)

    /** save a Black Panther character */
    router
        .route('/blackpanther')
        .post(ctrl.addCharacter)

    /** get a Black Panther character */
    router
        .route('/blackpanther/:id')
        .get(ctrl.getCharacter)

    /** delete a Black Panther character */
    router
        .route('/blackpanther/:id')
        .delete(ctrl.deleteCharacter)

    /** update a Black Panther character */
    router
        .route('/blackpanther/:id')
        .put(ctrl.updateCharacter)
}

Arriba hemos definido dos rutas básicas (/blackpanthery /blackpanther/:id) con diferentes métodos.

Como podemos ver, requerimos el controlador para que cada uno de los métodos de rutas pueda llamar a su función de controlador respectiva.

Finalmente, abrimos nuestro archivo index.js. Aquí, unimos los componentes en uno. Importamos la función de rutas que se nos expone en routes/route.jsy pasamos express.Router() como argumento a nuestro routes función. A continuación, nos conectamos a un MongoDB instancia y, a continuación, llame al app.listen() método para iniciar el servidor.

const express = require('express')
const mongoose = require('mongoose')
const bodyParser = require('body-parser')

const app = express()
const router = express.Router()
const routes = require('./routes/route')

const url = process.env.MONGODB_URI || "mongodb://localhost:27017/blackpanther"

mongoose.connect(url, {
    //useMongoClient: true
})

routes(router)
app.use(bodyParser.json())
app.use('/api/v1', router)

const port = process.env.PORT || 1000

app.listen(port, () => {
    console.log(`Black Panther API v1: ${port}`)
})

Agregue mLab Datastore a nuestros puntos finales de API

Todo este tiempo hemos estado usando una instancia local del almacén de datos de MongoDB. Implementaremos y accederemos a nuestra aplicación en una infraestructura de computación en la nube, por lo que no habrá un almacén de datos local presente. Para conservar nuestros datos, elegiremos una plataforma de datos como servicio (DaaS), mLab.

• Ir mLab
• Cree una cuenta, si aún no tiene una
• Vaya a su tablero, cree una nueva base de datos
• Copie la URL de conexión de la base de datos

Ahora que tenemos nuestra cadena de URL de conexión mLab, modificaremos index.js archivo:

...
const url = process.env.MONGODB_URI || "mongodb://<DB_USER>:<DB_PASSWORD>@<MLAB_URL>.mlab.com:<MLAB_PORT>/<DB_NAME>"
...

Pruebe nuestra aplicación localmente a través de cURL

Para probar nuestra aplicación en nuestra máquina local. Ejecute el siguiente comando para iniciar el servidor:

$ node .

Mostrará algo como esto en su terminal:

Te puede interesar:Problema diario de codificación: Programación de acertijos en su bandeja de entrada

$ node .
Black Panther API v1: 1000

Bien, ahora que nuestra API de Black Panther está en funcionamiento, podemos usar cURL para probar las API. Aquí publicaremos en la API para crear un nuevo personaje de Black Panther:

curl --request POST 
  --url http://localhost:1000/api/v1/blackpanther 
  --header 'content-type: application/json' 
  --data '{"alias":"tchalla","occupation":"King of Wakanda","gender":"male","place_of_birth":"Wakanda","abilities":"enhanced strength","played_by":"Chadwick Boseman"}'

Como tarea del lector, debe continuar y escribir rizo comandos para otros puntos finales de API también.

Implementa nuestra aplicación

Ahora nuestro nodejs La aplicación está lista para su implementación, pero antes de hacerlo, hay configuraciones que tenemos que modificar y agregar. Primero, vamos a crear un app.yaml archivo a nuestro proyecto.

los app.yaml El archivo es una configuración de tiempo de ejecución para el entorno de App Engine. app.yaml nos permite configurar nuestro entorno de App Engine (ya sea Node.js, GO, PHP, Ruby, Python, .NET o Java Runtime) antes de la implementación.

Con app.yaml archivo, podemos hacer lo siguiente:

• Asignar recursos de disco y red
• Seleccione el entorno flexible
• Seleccione la cantidad de núcleos de CPU que se asignarán
• Especifique el tamaño de memory_gb (RAM)

La lista es larga, puedes ir al recurso Configurando su aplicación con app.yaml para ver los ajustes de configuración completos seleccionados por Google.

OK, creemos app.yaml archivo en nuestro proyecto:

touch app.yaml

Abre el app.yaml archivo y agregue el siguiente contenido:

runtime: nodejs
env: flex

manual_scaling:
  instances: 1
resources:
  cpu: 1
  memory_gb: 0.5
  disk_size_gb: 10

Al observar la configuración anterior, le estamos diciendo a App Engine que nuestra aplicación se ejecutará en el entorno de tiempo de ejecución de Node.js, también el entorno debe configurarse como flexible.

La ejecución en un entorno flexible genera costos, por lo que reducimos la escala para reducir los costos agregando:

...
manual_scaling:
  instances: 1
resources:
  cpu: 1
  memory_gb: 0.5
  disk_size_gb: 10

Aquí, estamos especificando solo una instancia, un núcleo de CPU, 0.5G RAM y un tamaño de disco de 10G.

Te puede interesar:Docker: Una introducción de alto nivel

Esto es ideal para propósitos de prueba y no para uso en producción.

A continuación, tenemos que agregar un start en el scripts sección de nuestra package.json, esto lo usa el tiempo de ejecución de Node.js para iniciar nuestra aplicación cuando se implementa.

Sin el start propiedad, el verificador de tiempo de ejecución de Node.js arrojará el error «Error en la detección de la aplicación: Error: verificador de nodejs: no se encontró el inicio en la sección de scripts en el paquete.json ni server.js»

Abramos el package.json y añadir start en el scripts llave:

...
    "scripts": {
        "start": "node .",
        "test": "echo "Error: no test specified" && exit 1"
    },
...

Después de esto, ahora estamos listos para implementar. Para implementar nuestra aplicación, ejecute este comando:

$ gcloud app deploy

Probando nuestra aplicación implementada con cURL

Para probar nuestra API de aplicación Node.js implementada, necesitaremos usar la URL de destino Google App Engine nos dio.

curl --request POST 
  --url http://YOUR_TARGET_URL.appspot.com/api/v1/blackpanther 
  --header 'content-type: application/json' 
  --data '{"alias":"tchalla","occupation":"King of Wakanda","gender":"male","place_of_birth":"Wakanda","abilities":"enhanced strength","played_by":"Chadwick Boseman"}'

Con rizo enviamos un POST solicitud y una carga útil de personaje de Black Panther en nuestra aplicación Node.js implementada, utilizando el URL de destino como el nuestro url parámetro.

Nuestro punto final de API ejecuta la función POST, guarda la carga útil en nuestro mLab base de datos y nos envía el resultado:

{
    "alias":"tchalla",
    "occupation":"King of Wakanda",
    "gender":"male",
    "place_of_birth":"Wakanda",
    "abilities":"enhanced strength",
    "played_by":"Chadwick Boseman","_id":"5aa3a3905cd0a90010c3e1d9",
    "__v":0
}

¡Felicidades! Hemos implementado con éxito nuestra primera aplicación Node.js en Google App Engine.

Conclusión

Hemos visto en este artículo lo fácil y sin estrés que Google App Engine hace de nuestras vidas. Además, cómo con solo unos pocos comandos configura un potente motor de tiempo de ejecución e implementa su aplicación en él. No es necesario pensar en escalado, recursos, ancho de banda y el resto.

App Engine piensa por ti.

Te puede interesar:Cómo usar temporizadores y eventos en Node.js

Para marcar las ventajas que nos ofrece Google App Engine:

• Buen informe de errores
• Simplifica la seguridad de la API
• Fiabilidad y soporte
• Cuotas de uso para aplicaciones gratuitas

No dude en preguntar si tiene alguna pregunta o comentario en la sección de comentarios.