Criar um app para dispositivos móveis usando o Compute Engine e o REST

A execução do back-end móvel no Compute Engine e o uso do REST como protocolo de comunicação entre o app para dispositivos móveis e o servidor de back-end tem várias vantagens:

  • é a maneira mais rápida de mover um serviço atual, executado em uma máquina local ou virtual, para o Google Cloud;
  • oferece controle total sobre a configuração da máquina virtual e do servidor;
  • possibilita o uso de bibliotecas de terceiros;
  • permite configurar um autoescalador para escalonar o número de máquinas virtuais para atender à demanda.

A desvantagem de executar o serviço no Compute Engine é que você fica responsável por manter e atualizar o servidor.

Neste tutorial, você aprende a criar um app para dispositivos móveis de exemplo, denominado Stickynotes. Esse aplicativo usa o REST para se conectar a um serviço de back-end em execução no Compute Engine.

O exemplo Stickynotes inclui código de um app para dispositivos móveis de front-end e um serviço de back-end, que funcionam juntos no seguinte fluxo de trabalho:

  1. O app para dispositivos móveis permite inserir uma mensagem em um campo de texto.
  2. O app envia a mensagem para um endpoint REST no serviço de back-end.
  3. O serviço de back-end usa a biblioteca draw2d (em inglês) para criar uma imagem que contém a mensagem de texto.
  4. O serviço de back-end retorna a imagem para o app para dispositivos móveis.
  5. O app para dispositivos móveis exibe a imagem com a mensagem incorporada.

O app cliente é um app iOS e o serviço de back-end é escrito na linguagem de programação Go.

Objetivos

Neste tutorial, mostramos como fazer o seguinte:

  • Criar um app para dispositivos móveis iOS que se conecte a um endpoint REST no serviço de back-end.
  • Configurar e executar um serviço de back-end REST no Compute Engine.

Custos

Neste tutorial, usamos uma instância do Compute Engine, que é um componente faturável do Google Cloud.

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto. Usuários novos do GCP podem estar qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

Instale os seguintes softwares:

Clonar o código de amostra

Execute o seguinte comando para clonar o código de amostra:

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

Em seguida, navegue até o diretório /solutions/stickynoteapi/REST para encontrar o código de amostra dessa solução.

Executar o servidor localmente

No diretório /stickynoteapi/REST/Go, execute o seguinte comando:

sh SETUP

O comando exibe a seguinte saída:

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

A configuração também executa um cliente local para testar o servidor com a frase "Remember the milk". O servidor gera um arquivo message.png que contém a imagem correspondente.

Remember the milk.

Para gerar imagens baseadas nas suas próprias mensagens usando o cliente de linha de comando, execute o seguinte comando:

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

O arquivo /stickynoteapi/REST/Go/go/src/server/server.go contém o código que executa o servidor REST. A função principal define um gerenciador para o diretório de nível raiz e escuta o tráfego na porta 8080.

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

O servidor roteia solicitações recebidas para a função handler, que executa as seguintes ações:

  1. Extrai a mensagem de texto da solicitação REST.
  2. Usa as funções definidas em sticky.go para criar uma imagem com base na mensagem de texto.
  3. Retorna a imagem para o cliente em uma resposta 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)
	}
}

Deixe o servidor local em execução para que seja usado para testar o app cliente na próxima seção.

Executar o cliente iOS com o servidor local

  1. No diretório stickynoteapi/REST/Objective-C/, abra stickynotes.xcodeproj no Xcode.
  2. Selecione Produto > Executar para criar e iniciar o aplicativo cliente.
  3. Insira uma mensagem no campo de texto e toque em Retornar.

Uma imagem de nota adesiva amarela com a mensagem aparece abaixo do campo de texto.

Este é um teste...

O app cliente define o local do serviço de back-end no arquivo StickyNotesViewController.m. Para fins de teste, isto é inicialmente definido como localhost, na porta 8080.

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

Quando você toca em Retornar depois de inserir sua mensagem no campo de texto, o aplicativo a codifica em uma string de consulta e a envia para o servidor em uma solicitação REST. O aplicativo recebe a resposta REST, extrai a imagem gerada e a exibe em uma visualização de imagem. O código a seguir mostra a ação que manipula essas tarefas:

- (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];
}

Executar o servidor no Compute Engine

Para hospedar o servidor no Compute Engine, crie uma instância de computação:

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar instâncias de VM

  2. Clique em Criar instância.
  3. Defina Nome como sticky-rest.
  4. Na seção Disco de inicialização, clique em Alterar para começar a configurar o disco de inicialização.
  5. Na guia Public images, escolha Google Drawfork Debian GNU/Linux 9.

  6. Clique em Select.
  7. Na seção Firewall, selecione Permitir tráfego HTTP e Permitir tráfego HTTPS.
  8. Clique em Criar para criar a instância.

Para permitir solicitações de cliente para a instância, crie uma regra de firewall:

  1. Acesse a página Firewall no Console do Cloud.

    Acessar a página Firewall

  2. Na página Criar regra de firewall, insira as seguintes informações:

    • Nome: sticky-rest
    • Tags de destino: http-server
    • Intervalos de IP de origem: 0.0.0.0/0
    • Protocolo e portas: tcp:8080
  3. Clique em Criar.

Para iniciar o servidor na instância, clone o código do servidor e execute o script de instalação:

  1. Na lista de instâncias de máquina virtual, clique em SSH na linha da instância à qual você quer se conectar.

    Botão "SSH" ao lado do nome da instância.

  2. Anote o endereço IP da instância de VM. Você encontra esse endereço na coluna IP externo.
  3. Instale o Git na instância:

    sudo apt update
    sudo apt install git
    
  4. Instale as ferramentas do 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. Clone o código de servidor do Stickynotes:

    git clone https://github.com/GoogleCloudPlatform/ios-docs-samples.git
    
  6. Inicie o servidor do Stickynotes na instância. No diretório /solutions/stickynoteapi/REST/Go, execute o seguinte comando:

    sh SETUP
    

Para configurar e executar o app cliente:

  1. No Xcode, edite StickyNotesViewController.m para alterar o localhost para o valor do campo IP externo da instância do Compute Engine observada em uma etapa anterior.

    // static NSString \* const kHostAddress = @"localhost:8080";
    static NSString \* const kHostAddress = @"[YOUR-INSTANCE-EXTERNAL-IP]:8080";
    
  2. Selecione Arquivo > Salvar para salvar as alterações.

  3. Selecione Produto > Executar para criar e iniciar o aplicativo cliente.

  4. Insira uma mensagem no campo de texto e toque em Retornar.

Uma imagem de nota adesiva amarela com a mensagem substitui o fundo cinza.

Como testar em servidor remoto...

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir instâncias

Para excluir uma instância do Compute Engine:

  1. No Console do Cloud, acesse a página Instâncias de VM.

    Acessar instâncias de VM

  2. Marque a caixa de seleção de sua instância sticky-rest.
  3. Para excluir a instância, clique em Mais ações, clique em Excluir e siga as instruções.

Como excluir regras de firewall para a rede padrão

Para excluir uma regra de firewall:

  1. No Console do Cloud, acesse a página Firewall.

    Acessar o Firewall

  2. Marque a caixa de seleção de a regra de firewall que você quer excluir.
  3. Para excluir a regra de firewall, clique em Excluir.

A seguir

Neste exemplo, demonstramos os conceitos básicos de como conectar um app para dispositivos móveis ao código em execução no Compute Engine usando REST. Para estender esse exemplo em um app real, considere incluir as seguintes melhorias:

  • Adicionar um endereço IP externo estático ao servidor - por padrão, o endereço externo associado a uma instância do Compute Engine é temporário. Em um app de produção, conecte um endereço IP externo estático à instância. Para mais informações, consulte Como configurar o endereço IP de uma instância.

  • Usar credenciais para conectar-se a um servidor HTTPS - garanta que o serviço de back-end seja chamado apenas pelo app para dispositivos móveis. Para isso, exija que o app use credenciais para se autenticar no servidor. Proteja a privacidade dos dados que seus usuários enviam ao servidor usando o protocolo HTTPS criptografado em vez de HTTP. Para isso, execute um servidor NGINX como um proxy SSL na instância ou execute o servidor de back-end no ambiente flexível do App Engine. Para mais informações, consulte Como conectar-se de maneira segura às instâncias de VM.

  • Adicionar balanceamento de carga e escalonamento automático – manipule os picos de tráfego de maneira harmoniosa com a configuração de um balanceador de carga e um autoescalador para ativar outras instâncias quando a demanda crescer e rotear o tráfego de modo uniforme entre elas. Para mais informações, consulte Como configurar o balanceamento de carga HTTP(s) e Como fazer escalonamento automático de grupos de instâncias.

  • Explorar usando o protocolo gRPC em vez do RESTgRPC (em inglês) é uma biblioteca que permite a um app para dispositivos móveis chamar métodos diretamente em um serviço de back-end como se fossem objetos locais. Use o gRPC para aumentar a eficiência da largura de banda e reduzir a latência entre o app para dispositivos móveis e o serviço de back-end em execução no GCP. Para um exemplo de como usar o gRPC na amostra do Stickynotes, consulte Criar um aplicativo para dispositivos móveis usando o Google Compute Engine e o gRPC.

  • Pensar em outras opções de hospedagem para o serviço de back-end – o Compute Engine oferece o mais alto grau de controle sobre a máquina virtual, mas é preciso atualizar e gerenciar manualmente a instância. Para uma discussão sobre outras maneiras de hospedar um serviço de back-end para dispositivos móveis no Cloud Platform, consulte Criar aplicativos para dispositivos móveis usando o Google Cloud.