Compila una app para dispositivos móviles mediante Compute Engine y REST

Existen muchas ventajas si ejecutas el backend para dispositivos móviles en Compute Engine y usas REST como el protocolo de comunicación entre la app para dispositivos móviles y el servidor de backend:

  • Es la forma más rápida de mover un servicio existente, que se ejecuta en una máquina local o virtual, a Google Cloud.
  • Ofrece control total de la máquina virtual y configuración del servidor.
  • Puedes usar bibliotecas de terceros.
  • Puedes configurar un escalador automático para escalar la cantidad de máquinas virtuales a fin de satisfacer la demanda.

La desventaja de ejecutar el servicio en Compute Engine es que deberás mantener y actualizar el servidor.

En este instructivo, se explica cómo compilar una aplicación para dispositivos móviles de ejemplo llamada Stickynotes. Esta aplicación de ejemplo usa REST para conectarse a un servicio de backend que se ejecuta en Compute Engine.

La aplicación de ejemplo, Stickynotes, incluye un código de una aplicación para dispositivos móviles de frontend y servicio de backend, que trabajan juntos en el siguiente flujo de trabajo:

  1. La aplicación para dispositivos móviles te permite ingresar un mensaje en un campo de texto.
  2. La aplicación envía tu mensaje a un extremo de REST en el servicio de backend.
  3. El servicio de backend crea una imagen que contiene el mensaje de texto mediante la biblioteca draw2d.
  4. El servicio de backend le muestra la imagen a la aplicación para dispositivos móviles.
  5. La aplicación para dispositivos móviles muestra la imagen con tu mensaje incorporado.

La aplicación cliente es una aplicación para iOS, y el servicio de backend está escrito en el lenguaje de programación Go.

Objetivos

En este instructivo, aprenderás a completar los siguientes pasos:

  • Crear una aplicación para dispositivos móviles de iOS que se conecte con un extremo de REST en el servicio de backend
  • Configurar y ejecutar un servicio de backend de REST en Compute Engine

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

  • Compute Engine

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

  4. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  5. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

Instala el siguiente software:

Clona el código de muestra

Ejecuta el siguiente comando a fin de clonar el código de muestra:

git clone https://github.com/GoogleCloudPlatform/ios-docs-samples.git

Luego, ve al directorio /solutions/stickynoteapi/REST para encontrar el código de muestra de esta solución.

Ejecuta el servidor de manera local

En el directorio /stickynoteapi/REST/Go, ejecuta el siguiente comando:

sh SETUP

El comando muestra el siguiente resultado:

1. Set gopath and search path
2. Get the server and client dependencies
3. Build the server and client
4. Stop any previously-running instances of the server
5. Start the server
6. Run the client
2016/03/02 11:34:48 OK: message.png
7. Open the image in message.png

Con esta configuración, también se ejecuta un cliente local para probar el servidor con la frase “Remember the milk” (No olvides la leche). El servidor genera un archivo message.png que contiene la imagen correspondiente.

Remember the milk (No olvides la leche).

Para generar imágenes basadas en tus propios mensajes con el cliente de línea de comandos, ejecuta el siguiente comando:

./client "This is a test..."

El archivo /stickynoteapi/REST/Go/go/src/server/server.go contiene el código que ejecuta el servidor REST. La función principal define un controlador para el directorio de nivel de raíz y escucha en búsqueda de tráfico en el puerto 8080.

func main() {
	http.HandleFunc("/stickynote", handler)
	http.ListenAndServe(":8080", nil)
	//http.ListenAndServeTLS(":443", "ssl.crt", "ssl.key", nil)
}

El servidor enruta las solicitudes entrantes a la función handler, que realiza las siguientes acciones:

  1. Extrae el mensaje de texto de la solicitud de REST.
  2. Usa las funciones definidas en sticky.go para compilar una imagen basada en el mensaje de texto.
  3. Muestra una imagen al cliente en una respuesta REST.
func handler(w http.ResponseWriter, r *http.Request) {
	var sticky Sticky
	sticky.Message = r.FormValue("message")
	sticky.Centered = false
	stickyBytes, err := sticky.DrawPNG(512, 512)
	if err == nil {
		w.Write(*stickyBytes)
	}
}

Deja el servidor local ejecutándose a fin de poder usarlo para probar la aplicación cliente en la próxima sección.

Ejecuta el cliente de iOS con el servidor local

  1. En el directorio stickynoteapi/REST/Objective-C/, abre stickynotes.xcodeproj en Xcode.
  2. Selecciona Producto > Ejecutar para compilar y, luego, iniciar la app cliente.
  3. Ingresa un mensaje en el campo de texto y presiona Intro.

Aparecerá una imagen de una nota adhesiva amarilla con tu mensaje debajo del campo de texto.

This is a test… (Esta es una prueba…)

La app cliente establece la ubicación del servicio de backend en el archivo StickyNotesViewController.m. Para fines de prueba, esto se establece inicialmente en localhost, en el puerto 8080.

static NSString * const kHostAddress = @"localhost:8080";

Cuando presionas Intro después de ingresar tu mensaje en el campo de texto, la app codifica el mensaje en una cadena de consulta y la envía al servidor en una solicitud de REST. La app recibe la respuesta de REST, extrae la imagen generada y la muestra en una vista de imagen. El siguiente código muestra la acción que controla estas tareas:

- (IBAction) textFieldDidEndEditing:(UITextField *)textField
{
  NSString *queryString = [NSString stringWithFormat:@"http://%@/stickynote?message=%@",
                           kHostAddress,
                           [textField.text urlencode]];
  NSURL *URL = [NSURL URLWithString:queryString];
  _request = [NSMutableURLRequest requestWithURL:URL];

  NSURLSession *session = [NSURLSession sharedSession];
  _task = [session dataTaskWithRequest:_request
                     completionHandler:
           ^(NSData *data, NSURLResponse *response, NSError *error) {
             UIImage *image = [UIImage imageWithData:data];
             dispatch_async(dispatch_get_main_queue(), ^{
                              self.imageView.image = image;
                            });
           }];
  [_task resume];
}

Ejecuta el servidor en Compute Engine

Si deseas alojar el servidor en Compute Engine, crea una instancia de procesamiento:

  1. En Google Cloud Console, ve a la página Crear una instancia.

    Ir a Crear una instancia

  2. Establece el Nombre como sticky-rest.
  3. En la sección Disco de arranque, haz clic en Cambiar para comenzar a configurar el disco de arranque.
  4. En la pestaña Public images, selecciona Google Drawfork Debian GNU/Linux 9.
  5. Haga clic en Seleccionar.
  6. En la sección Firewall, selecciona Permitir tráfico HTTP y Permitir tráfico HTTPS.
  7. Para crear la VM, haz clic en Crear.

Si deseas permitir solicitudes de clientes a la instancia, debes crear una regla de firewall:

  1. Ve a la página Firewall en Cloud Console.

    Ir a la página Firewall

  2. En la página Crear una regla de firewall, ingresa la siguiente información:

    • Nombre: sticky-rest
    • Etiquetas de destino: http-server
    • Rangos de IP de origen: 0.0.0.0/0
    • Protocolo y puertostcp:8080
  3. Haz clic en Crear.

Si deseas iniciar el servidor en la instancia, debes clonar el código del servidor y ejecutar la secuencia de comandos de configuración:

  1. En la lista de instancias de máquinas virtuales, haz clic en SSH en la fila de la instancia a la que deseas conectarte.

    Botón SSH junto al nombre de la instancia.

  2. Anota la dirección IP de tu instancia de VM. Puedes encontrarla en la columna IP externa.
  3. Instala Git en la instancia:

    sudo apt update
    sudo apt install git
    
  4. Instale las herramientas de Go:

    sudo wget https://storage.googleapis.com/golang/go1.10.linux-amd64.tar.gz
    sudo tar -C /usr/local -xzf go1.10.linux-amd64.tar.gz
    export PATH="/usr/local/go/bin:${PATH}"
    
  5. Clona el código del servidor de Stickynotes:

    git clone https://github.com/GoogleCloudPlatform/ios-docs-samples.git
    
  6. Inicia el servidor de Stickynotes en la instancia. En el directorio /solutions/stickynoteapi/REST/Go, ejecuta el siguiente comando:

    sh SETUP
    

Si deseas configurar y ejecutar la app cliente, haz lo siguiente:

  1. En Xcode, edita StickyNotesViewController.m para cambiar localhost por el valor del campo IP externa de tu instancia de Compute Engine que se indicó en un paso anterior.

    // static NSString \* const kHostAddress = @"localhost:8080";
    static NSString \* const kHostAddress = @"[YOUR-INSTANCE-EXTERNAL-IP]:8080";
    
  2. Selecciona Archivo > Guardar para guardar los cambios.

  3. Selecciona Producto > Ejecutar para compilar y, luego, iniciar la app cliente.

  4. Ingresa un mensaje en el campo de texto y presiona Intro.

Una imagen de una nota adhesiva amarilla con el mensaje reemplazará el fondo gris.

Testing on remote server…

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra instancias

Para borrar una instancia de Compute Engine, haz lo siguiente:

  1. En Cloud Console, ve a la página Instancias de VM.

    Ir a Instancias de VM

  2. Selecciona tu instancia sticky-rest en la casilla de verificación de .
  3. Para borrar la instancia, haz clic en Más acciones, en Borrar y, luego, sigue las instrucciones.

Borra reglas de firewall para la red predeterminada

Para borrar una regla de firewall, haz lo siguiente:

  1. En Cloud Console, ve a la página Firewall.

    Ir a Firewall

  2. Selecciona la casilla de verificación para es la regla de firewall que quieres borrar.
  3. Para borrar la regla de firewall, haz clic en Borrar.

Próximos pasos

En este ejemplo, se muestran los conceptos básicos de cómo conectar una app para dispositivos móviles al código que se ejecuta en Compute Engine mediante REST. A fin de llevar este ejemplo a una app real, considera agregar las mejoras siguientes:

  • Agrega una dirección IP externa estática al servidor: de forma predeterminada, la dirección externa asociada con una instancia de Compute Engine es transitoria. En una app de producción, adjunta una dirección IP externa a tu instancia. Para obtener más información, consulta Reserva una dirección IP externa estática.

  • Usa credenciales si deseas conectarte a un servidor HTTPS: asegúrate de que solo tu app para dispositivos móviles pueda llamar a tu servicio de backend; a fin de hacerlo, debes solicitar que la app use credenciales con el fin de autenticarse al servidor. Protege la privacidad de los datos que tus usuarios envían al servidor; para eso, usa el protocolo HTTPS encriptado en lugar de HTTP. Con este fin, puedes ejecutar un servidor NGINX como proxy SSL en tu instancia o ejecutar tu servidor de backend en el entorno flexible de App Engine. Para obtener más información, consulta Conéctate a instancias de VM de forma segura.

  • Agrega balanceo de cargas y ajuste de escala automático: controla los picos de tráfico con facilidad; para ello, debes configurar un balanceador de cargas y un escalador automático a fin de iniciar instancias adicionales cuando crezca la demanda y enrutar el tráfico de manera uniforme a través de estas instancias. Para obtener más información, consulta Conceptos del balanceo de cargas de HTTP(S) y Ajuste de escala automático de grupos de instancias.

  • Analiza la posibilidad de usar un protocolo gRPC en lugar de REST: gRPC es un framework que le permite a una app para dispositivos móviles llamar a métodos en un servicio de backend directamente como si fuera un objeto local. Puedes usar gRPC con el fin de hacer que tu app para dispositivos móviles tenga un ancho de banda más eficiente y reducir la latencia entre tu app y el servicio de backend que se ejecuta en GCP. Para ver un ejemplo de cómo usar gRPC en la muestra de Stickynotes, consulta la página Compilar una aplicación para dispositivos móviles con Google Compute Engine y gRPC

  • Considera otras opciones de hosting para el servicio de backend: Compute Engine te ofrece un mayor nivel de control de tu máquina virtual, pero deberás actualizar y administrar tu instancia de forma manual. Si deseas conocer otras maneras de alojar un servicio de backend para dispositivos móviles en Cloud Platform, consulta Compila apps para dispositivos móvil mediante Google Cloud.