Compilar una aplicación para dispositivos móviles con Google Compute Engine y gRPC

El marco de trabajo de gRPC permite que una aplicación para dispositivos móviles llame directamente a los métodos en un servicio de backend como si fuera un objeto local. Puedes usar gRPC con el objetivo de que tu aplicación para dispositivos móviles tenga un ancho de banda más eficiente y reducir la latencia entre la aplicación y el servicio de backend que se ejecuta en Google Cloud Platform.

Ejecutar el backend para dispositivos móviles en Google Compute Engine y usar gRPC como el protocolo de comunicación entre la aplicación y el servidor de backend tiene muchas ventajas.

  • Es la forma más rápida de mover un servicio existente, que se ejecuta en una máquina local o virtual, a Cloud Platform.
  • Tiene mayor eficiencia de ancho de banda en comparación con HTTP/S.
  • 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 de forma manual. Si deseas obtener otras opciones de compilación de servicios de backend, consulta Compilar aplicaciones para dispositivos móviles con Google Cloud Platform.

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 gRPC para conectarse a un servicio de backend que se ejecuta en Compute Engine.

La aplicación de ejemplo, Stickynotes, incluye un código de aplicación para dispositivos móviles frontend y servicio de backend. En la aplicación para dispositivos móviles, puedes ingresar un mensaje en un campo de texto. La aplicación envía el mensaje a un servicio de backend mediante gRPC. Este servicio convierte el mensaje de texto en una imagen con draw2d y, luego, muestra la imagen en la aplicación para dispositivos móviles. La aplicación para dispositivos móviles muestra el mensaje como una imagen con un fondo amarillo.

La aplicación cliente es una aplicación para iOS y el servicio de backend se escribe en Go.

Objetivos

En este instructivo, aprenderás a realizar lo siguiente:

  • Crear una aplicación para dispositivos móviles de iOS que use gRPC a fin de conectarse a un servicio de backend.
  • Configurar y ejecutar un servicio de backend de gRPC en Compute Engine.

Costos

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

  • Google Compute Engine

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto. Los usuarios nuevos de Cloud Platform pueden optar por una prueba gratuita.

Antes de comenzar

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

    Ir a la página Administrar recursos

  2. Selecciona un proyecto o haz clic en Crear proyecto para crear un proyecto de GCP nuevo.

  3. En el cuadro de diálogo, ponle nombre a tu proyecto. Toma nota de tu ID del proyecto generado.

  4. Haz clic en Crear para crear un proyecto nuevo.

    Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

Una vez que realices estos pasos, instala el siguiente software:

  • Git
  • Xcode 7.2 o versión posterior
  • Go

    Asegúrate de que la instalación de Go esté en la variable PATH, normalmente en /usr/local/go/bin.

    Instala Go con tu cuenta de usuario como propietario. Si lo instalas como administrador, ejecuta el siguiente comando en el directorio donde está instalado Go para cambiar la propiedad reemplazando <username> por tu cuenta de usuario.

    sudo chown -R <username> go
    
  • CocoaPods

    sudo gem install cocoapods
    
  • Homebrew

    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
    
  • protoc con el complemento de gRPC

    curl -fsSL https://goo.gl/getgrpc | bash -
    

Clonar el código de muestra

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

Luego, navega a /solutions/stickynoteapi/gRPC para encontrar el código de ejemplo de esta solución.

Ejecutar el servidor de manera local

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

sh SETUP

Deberías ver el siguiente resultado:

0. Ensure that protoc is installed.
/usr/local/bin/protoc
OK
1. Set gopath and search path
2. Get the Go plugin for protoc
3. Run protoc to generate the service API code
4. Get the server and client dependencies
5. Build the server and client
6. Stop any previously-running instances of the server
No matching processes belonging to you were found
7. Start the server
8. Run the client
2016/03/03 15:53:21 OK: message.png
9. Open the image in message.png

La configuración también ejecuta un cliente local para probar el servidor con la frase "Remember The Milk" (No olvides la leche) y genera una imagen con ese mensaje.

Remember The Milk.

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 /solutions/stickynoteapi/gRPC/Go/go/src/server/server.go contiene el código que ejecuta el servidor de gRPC. El código también define una estructura StickyNoteServer que contiene dos elementos: uno que representa la solicitud y el otro la respuesta.

type StickyNoteServer struct{}

var stickyNoteServer StickyNoteServer

La función main define un servidor de gRPC para el directorio de nivel de raíz, el cual escucha el tráfico en el puerto 8080. Debido a que el servidor no especifica una dirección IP o un dominio, puedes ejecutar este código en Compute Engine sin tener que realizar ninguna modificación.

func main() {
	var err error
	var lis net.Listener
	var grpcServer *grpc.Server
	if !useSSL {
		lis, err = net.Listen("tcp", ":8080")
		if err != nil {
			log.Fatalf("failed to listen: %v", err)
		}
		grpcServer = grpc.NewServer()
	} else {
		certFile := "ssl.crt"
		keyFile := "ssl.key"
		creds, err := credentials.NewServerTLSFromFile(certFile, keyFile)
		lis, err = net.Listen("tcp", ":443")
		if err != nil {
			log.Fatalf("failed to listen: %v", err)
		}
		grpcServer = grpc.NewServer(grpc.Creds(creds))
	}
	pb.RegisterStickyNoteServer(grpcServer, &stickyNoteServer)
	grpcServer.Serve(lis)
}

La función Get recibe el mensaje en la solicitud de gRPC, usa las funciones definidas en sticky.go para compilar una imagen basada en ese mensaje y muestra la imagen en una respuesta de gRPC.

func (s *StickyNoteServer) Get(ctx context.Context, r *pb.StickyNoteRequest) (*pb.StickyNoteResponse, error) {
	var sticky Sticky
	sticky.Message = r.Message
	sticky.Centered = false

	resp := &pb.StickyNoteResponse{}
	stickyBytes, err := sticky.DrawPNG(512, 512)
	resp.Image = *stickyBytes

	return resp, err
}

Deja el servidor local en ejecución de modo que puedas usarlo para probar la aplicación de cliente.

Ejecutar el cliente de iOS con el servidor local

  1. En el directorio /stickynoteapi/gRPC/Objective-C, ejecuta el siguiente comando para instalar las dependencias de BoringSSL, Protobuf y gRPC. El proceso de instalación puede tardar varios minutos.

    pod install
    

    Deberías ver el siguiente resultado:

    Analyzing dependencies
    Fetching podspec for `stickynote` from `stickyapi`
    Downloading dependencies
    Installing BoringSSL (2.0)
    Installing Protobuf (3.0.0-beta-2)
    Installing gRPC (0.12.0)
    Installing stickynote (0.0.1)
    Generating Pods project
    Integrating client project
    
    [!] Please close any current Xcode sessions and use
    `stickynotes.xcworkspace` for this project from now on.
    Sending stats
    Pod installation complete! There is 1 dependency from the Podfile and 4
    total pods installed.
    
  2. Abre el lugar de trabajo compilado por Cocoapods, stickynotes.xcworkspace, en Xcode.

  3. Selecciona Producto > Esquema > stickynotes para elegir el esquema correcto.

  4. Selecciona Producto > Ejecutar para compilar y, luego, iniciar la aplicación de cliente. Ignora las advertencias de Protobuf y gRPC.

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

Debería aparecer una imagen con una nota adhesiva amarilla con tu mensaje debajo del campo de texto.

This is a test…

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

static NSString * const kHostAddress = @"localhost";

Si presionas Intro después de ingresar tu mensaje en el campo de texto, se activa la siguiente acción. La acción codifica el mensaje en una string de consulta. Luego, pasa la consulta a una conexión de transmisión abierta.

- (IBAction)textDidChange:(UITextField *) sender {
  if ([_streamSwitch isOn]) {
    StickyNoteRequest *request = [StickyNoteRequest message];
    request.message = sender.text;
    [_writer writeValue:request];
  }
}

La conexión de transmisión se abre con la función openStreamingConnection.

- (void) openStreamingConnection {
  _writer = [[GRXBufferedPipe alloc] init];
  _updateCall = [_client RPCToUpdateWithRequestsWriter:_writer
                                          eventHandler:^(BOOL done, StickyNoteResponse *response, NSError *error) {
                                            [self handleStickynoteResponse:response andError:error];
                                          }];
  [_updateCall start];
}

Ejecutar el servidor en Compute Engine

  1. Ve a la página Create an instance (Crear una instancia) en Google Cloud Platform Console.

    Ir a la página Crear una instancia

    1. Configura Name (Nombre) como sticky-grpc.
    2. Selecciona Create (Crear).

    Cree una instancia

  2. Ve a la página Create a firewall rule (Crear una regla de firewall) en GCP Console.

    Ir a la página Crear una regla de firewall

    1. En Name (Nombre), ingresa default-allow-grpc.
    2. En Source filter (Filtro de fuente), selecciona Allow from any source (0.0.0.0./0) (Permitir desde cualquier fuente).
    3. En Allowed protocols and ports (Protocolos y puertos permitidos), ingresa tcp:8080.
    4. Selecciona Create (Crear).

    Selecciona SSH

  3. Ve a la página de VM Instances en GCP Console.

    Ir a la página de VM Instances

    1. Ten en cuenta la dirección IP externa junto a sticky-grpc.
    2. Selecciona SSH

    Selecciona SSH

  4. Instala Git en la instancia.

    sudo apt-get update
    sudo apt-get install git
    
  5. Clona el código del servidor de Stickynotes.

    git clone https://github.com/GoogleCloudPlatform/ios-docs-samples.git
    
  6. Instala Go y protoc. En el directorio /solutions/stickynoteapi/gRPC/Go/, ejecuta el siguiente comando.

    sh INSTALL
    
  7. Carga las variables de entorno nuevas establecidas por la secuencia de comandos INSTALL.

    source $HOME/.bash_profile
    
  8. Inicia el servidor de Stickynotes en la instancia. En el directorio /solutions/stickynoteapi/gRPC/Go/, ejecuta el siguiente comando.

    sh SETUP
    
  9. En Xcode, edita StickyNotesViewController.m para cambiar el localhost en la dirección IP externa de la instancia de Compute Engine del paso 2.

    // static NSString \* const kHostAddress = @"localhost";
    static NSString \* const kHostAddress = @"198.51.100.0";
    
  10. Selecciona Archivo > Guardar para guardar los cambios.

  11. Selecciona Producto > Esquema > stickynotes para elegir el esquema correcto.

  12. Selecciona Producto > Ejecutar para compilar y, luego, iniciar la aplicación de cliente.

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

Una imagen de una nota adhesiva amarilla con tu mensaje debería reemplazar el fondo gris.

Testing on remote server…

Limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Cómo borrar 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, haz lo siguiente:

  1. En la GCP Console, dirígete a la página Proyectos.

    Ir a la página Proyectos

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

Borrar instancias

Para borrar una instancia de Compute Engine:

  1. En GCP Console, dirígete a la página Instancias de VM.

    Ir a la página Instancias de VM

  2. Haz clic en la casilla de verificación junto ala instancia que deseas borrar.
  3. Haz clic en el botón Borrar en la parte superior de la página para borrar la instancia.

Borrar las reglas de firewall para la red predeterminada

Para borrar una regla de firewall, realiza los siguientes pasos:

  1. En GCP Console, dirígete a la página Reglas de firewall.

    Ir a la página de Reglas de firewall.

  2. Haz clic en la casilla de verificación junto ala regla de firewall que deseas borrar.
  3. Haz clic en el botón Borrar en la parte superior de la página para eliminar la regla de firewall.

Pasos siguientes

En este ejemplo se muestran los conceptos básicos de cómo conectar una aplicación para dispositivos móviles al código que se ejecuta en Compute Engine a través de gRPC. A fin de ampliar este ejemplo en una aplicación real, considera agregar las siguientes mejoras:

  • Agregar una dirección IP estática al servidor: de forma predeterminada, la dirección externa asociada con una instancia de Compute Engine es transitoria. Para obtener una aplicación de producción, debes adjuntar una dirección IP estática a la instancia. Para obtener más información, consulta Configurar una dirección IP de la instancia.

  • Agregar balanceo de cargas y ajuste de escala automático: controla los picos de tráfico fácilmente; para ello, debes configurar un balanceador de cargas y 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 Configurar el balanceo de cargas HTTP(s) y Ajuste de escala automático de instancias.

  • Considerar otras opciones de hosting para el servicio de backend: Compute Engine te ofrece un mayor nivel de control de la 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 en Cloud Platform, consulta Compilar aplicaciones para dispositivos móviles con Google Cloud Platform.

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…