Criar um aplicativo para dispositivos móveis usando o Google Compute Engine e gRPC

A biblioteca gRPC permite que um aplicativo para dispositivos móveis chame diretamente métodos em um serviço de back-end como se fosse um objeto local. O gRPC pode ser usado para tornar o aplicativo para dispositivos móveis mais eficiente em termos de largura de banda e reduzir a latência entre o aplicativo e o serviço de back-end executado no Google Cloud Platform.

Executar o back-end móvel no Google Compute Engine e usar o gRPC como protocolo de comunicação entre o aplicativo para dispositivos móveis e o servidor do back-end tem diversas vantagens.

  • Essa é a maneira mais rápida de mover um serviço existente, em execução no local ou em uma máquina virtual, para o Google Cloud Platform.
  • A eficiência de largura de banda em relação a HTTP/S é melhor.
  • É possível controlar totalmente a configuração da máquina virtual e do servidor.
  • É possível usar bibliotecas de terceiros.
  • É possível configurar um autoescalador para escalar o número de máquinas virtuais para atender à demanda.

A desvantagem de executar o serviço no Google Compute Engine é que você é o responsável por gerenciar e atualizar o servidor manualmente. Para outras opções de como criar serviços de back-end móveis, consulte Criar aplicativos para dispositivos móveis usando o Google Cloud Platform.

Neste tutorial, você aprenderá como criar um aplicativo de exemplo para dispositivos móveis, chamado Stickynotes. Este aplicativo de exemplo usa o gRPC para se conectar a um serviço de back-end executado no Google Compute Engine.

A amostra do Stickynotes inclui o código em um aplicativo para dispositivos móveis front-end e um serviço de back-end. No aplicativo, é possível inserir uma mensagem em um campo de texto. Ele envia a mensagem para um serviço de back-end usando o gRPC. O serviço então converte a mensagem de texto para imagem usando o draw2d e depois devolve a imagem para o aplicativo. Este então exibe sua mensagem como uma imagem com um plano de fundo amarelo.

O aplicativo cliente é um iOS, e o serviço de back-end está escrito em Go.

Objetivos

Neste tutorial, você aprenderá a:

  • criar um aplicativo para dispositivo móvel iOS que use gRPC para se conectar a um serviço back-end;
  • configurar e executar um serviço de back-end gRPC no Compute Engine.

Custos

Neste tutorial, há componentes do Cloud Platform que podem ser faturáveis, entre eles os seguintes:

  • Google Compute Engine

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

Antes de começar

  • Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  • Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  • Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  • Instale os seguintes softwares:

    • Git
    • XCode 7.2 ou posterior
    • Go

      • Verifique se a instalação do Go está na variável PATH, geralmente /usr/local/go/bin.
      • Instale o Go com sua conta de usuário como o proprietário. Se for instalado como raiz, execute o comando a seguir no diretório onde o Go está instalado para alterar a propriedade, substituindo <username> pelo seu nome de usuário.

        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 com o plug-in gRPC

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

    Clonar o código de amostra

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

    Depois, navegue até /solutions/stickynoteapi/gRPC para encontrar o código de amostra para esta solução.

    Executar o servidor localmente

    No diretório /stickynoteapi/gRPC/Go, execute este comando:

    sh SETUP
    

    Você verá a seguinte saída:

    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
    

    A configuração também executa um cliente local para testar o servidor com a frase "Remember the milk." e gera uma imagem com essa mensagem.

    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 /solutions/stickynoteapi/gRPC/Go/go/src/server/server.go contém o código que executa o servidor gRPC. O código também define uma estrutura: o StickyNoteServer que contém dois elementos, um que representa a Solicitação e o outro, a Resposta.

    type StickyNoteServer struct{}
    
    var stickyNoteServer StickyNoteServer

    A função main define um servidor gRPC para o diretório de nível raiz, que detecta o tráfego na porta 8080. Como o servidor não especifica um endereço IP ou um domínio, é possível executar esse código no Google Compute Engine sem modificações.

    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)
    }

    A função Get recebe a mensagem na solicitação gRPC, usa as funções definidas em sticky.go para criar uma imagem com base nessa mensagem e depois retorna a imagem em uma resposta 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
    }

    Deixe o servidor local em execução para que seja possível usá-lo para testar o aplicativo cliente.

    Executar o cliente iOS com o servidor local

    1. No diretório /stickynoteapi/gRPC/Objective-C, execute o comando a seguir para instalar as dependências BoringSSL, Protobuf e gRPC. Esse processo pode demorar vários minutos.

      pod install
      

      Você verá a seguinte saída:

      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. Abra o espaço de trabalho criado pelo Cocoapods, stickynotes.xcworkspace, no Xcode.

    3. Selecione Produto > Esquema > stickynotes para escolher o esquema correto.

    4. Selecione Produto > Executar para criar e iniciar o aplicativo cliente. Ignore os avisos no Protobuf e no gRPC.

    5. Digite uma mensagem no campo de texto e toque em Retornar.

    Uma imagem de uma nota adesiva amarela com sua mensagem aparecerá abaixo do campo de texto.

    Isto é um teste...

    O aplicativo cliente define o local do serviço de back-end no arquivo StickyNotesViewController.m. Para fins de teste, ele é inicialmente configurado para localhost.

    static NSString * const kHostAddress = @"localhost";

    Quando você toca em Retornar depois de inserir sua mensagem no campo de texto, a ação seguinte dispara. A ação codifica a mensagem em uma string de consulta. Em seguida, passa a consulta em uma conexão de streaming aberto.

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

    A conexão de streaming é aberta pela função 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];
    }

    Executar o servidor no Compute Engine

    1. Acesse a página Criar uma instância no Console do Google Cloud Platform.
      Acessar a página "Criar uma instância"

      1. Configure Nome como sticky-grpc.
      2. Selecione Criar.

      Criar uma instância

    2. Acesse a página Criar uma regra de firewall no Console do GCP.
      Acessar a página "Criar regra de firewall"

      1. Em Nome, digite default-allow-grpc.
      2. Em Filtro de origem, selecione Permitir de qualquer origem (0.0.0.0./0).
      3. Em Portas e protocolos permitidos, digite tcp:8080.
      4. Selecione Criar.

      Selecionar SSH

    3. Acesse a página Ver instâncias de VM no Console do GCP.
      Acessar a página "Ver instâncias de VM"

      1. Observe o endereço IP externo ao lado de sticky-grpc.
      2. Selecione SSH.

      Selecionar SSH

    4. Instale o Git na instância.

      sudo apt-get update
      sudo apt-get install git
      
    5. Clone o código de servidor do Stickynotes.

      git clone https://github.com/GoogleCloudPlatform/ios-docs-samples.git
      
    6. Instale Go e protoc. No diretório /solutions/stickynoteapi/gRPC/Go/, execute o comando a seguir.

      sh INSTALL
      
    7. Carregue as novas variáveis de ambiente definidas pelo script INSTALL.

      source $HOME/.bash_profile
      
    8. Inicie o servidor do Stickynotes na instância. No diretório /solutions/stickynoteapi/gRPC/Go/, execute o comando a seguir.

      sh SETUP
      
    9. No Xcode, edite StickyNotesViewController.m para mudar o localhost para o endereço IP externo da sua instância do Google Compute Engine da Etapa 2.

      // static NSString \* const kHostAddress = @"localhost";
      static NSString \* const kHostAddress = @"198.51.100.0";
      
    10. Selecione Arquivo > Salvar para salvar suas alterações.

    11. Selecione Produto > Esquema > stickynotes para escolher o esquema correto.

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

    13. Digite uma mensagem no campo de texto e toque em Retornar.

    Uma imagem de uma nota adesiva amarela com sua mensagem vai substituir o plano de fundo cinza.

    Como testar em servidor remoto...

    Como fazer a limpeza

    Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform:

    Excluir o projeto

    A maneira mais fácil de evitar a cobrança é excluir o projeto criado para o tutorial.

    Para excluir o projeto:

    1. No Console do GCP, acesse a página "Projetos".

      Acessar a página Projetos

    2. Na lista de projetos, selecione um e clique em Excluir projeto.
    3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

    Como excluir instâncias

    Para excluir uma instância do Compute Engine:

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

      Acessar a página "Instâncias de VMs"

    2. Clique na caixa de seleção ao lado da da instância que deseja excluir.
    3. Clique no botão Excluir na parte superior da página para excluir a instância.

    Como excluir regras de firewall para a rede padrão

    Para excluir uma regra de firewall:

    1. No Console do GCP, acesse a página "Regras de firewall".

      Acessar a página "Regras de firewall"

    2. Clique na caixa de seleção ao lado da da regra de firewall que deseja excluir.
    3. Clique no botão Excluir na parte superior da página para excluir a regra de firewall.

    Próximas etapas

    Neste exemplo, são demonstrados os princípios básicos de como conectar um aplicativo para dispositivos móveis ao código em execução no Google Compute Engine usando o gRPC. Para estender esse exemplo para um aplicativo real, é possível adicionar as seguintes melhorias:

    • Adicione um endereço IP estático ao seu servidor - por padrão, o endereço externo associado a uma instância do Google Compute Engine é temporário. Para um aplicativo de produção, é preciso anexar um endereço IP estático à instância. Para mais informações, consulte Configurar o endereço IP de uma instância.

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

    • Considere outras opções de hospedagem para seu serviço de back-end -- o Google Compute Engine oferece o melhor grau de controle sobre sua máquina virtual, mas ao custo da necessidade de atualizar e gerenciar manualmente a instância. Para conhecer 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 Platform.

    Esta página foi útil? Conte sua opinião sobre:

    Enviar comentários sobre…