Criar um aplicativo para dispositivos móveis usando o Google Compute Engine e o 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. Novos usuários do Cloud Platform podem estar qualificados para uma avaliação gratuita.

Antes de começar

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

    Acessar a página Gerenciar recursos

  2. Selecione um projeto ou clique em Criar para criar um projeto do GCP.

    Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

Depois de executar essas etapas, instale os softwares a seguir:

  • 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 você instalá-lo como root, execute o comando a seguir no diretório em que 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 dessa 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. Defina o 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:

Como 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 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. In the GCP Console, go to the Firewall Rules page.

    Go to the Firewall Rules page

  2. Click the checkbox for the firewall rule you want to delete.
  3. Click Delete to delete the firewall rule.

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 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…