Criar um canal de entrega móvel sem servidor

Neste tutorial descrevemos como criar um canal de entrega móvel, sem servidor, no Google Cloud Platform (GCP):

• Você receberá orientação sobre como configurar um aplicativo de teste para Android, criá-lo e distribuí-lo usando comandos do Gradle na máquina local. Com esses comandos, é possível criar o pacote de aplicativos para Android (APK, na sigla em inglês) e fazer o upload no Beta by Crashlytics para distribuição usando a plataforma de distribuição móvel do Fabric para Firebase.

• Para automatizar esse processo, crie uma imagem do Docker semi-personalizada para criar aplicativos para Android com o Cloud Build, chamado aqui de Android Builder. Para concluir a automatização, você conseguirá acionar o Android Builder com alterações no código-fonte do aplicativo para Android por meio deste tutorial.

Objetivos

• Criar uma tarefa de versão que crie um APK assinado.
• Criar uma tarefa de versão que use o Crashlytics para distribuir novas versões.
• Criar uma imagem do Docker personalizada, o Android Builder, que tenha as dependências do Android SDK necessárias.
• Crie um acionador de versão no GCP que use a imagem do Docker do Android Builder para criar o APK assinado e distribuí-lo usando o Fabric Crashlytics.

Custos

Neste tutorial, usamos componentes faturáveis do GCP, inclusive este:

• Cloud Build

A imagem base do Android Builder é de cerca de 1,9 GB. O custo estimado feito pela calculadora de preços para o armazenamento do ambiente de 2 GB gira em torno de US$ 0,05 por mês. A criação da imagem base do Android Builder leva aproximadamente 11 minutos e custa US$ 0,03. Cada versão extra leva cerca de 5 minutos e custa em torno de US$ 0,02. Para ver mais informações, consulte os preços do Cloud Build.

Antes de começar

1. Faça login na sua Conta do Google.

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

2. Selecione ou crie um projeto do GCP.

   Observação: se você não pretende manter os recursos criados neste tutorial, crie um novo projeto em vez de selecionar um existente. Depois de terminar, é possível excluir o projeto, removendo todos os recursos associados ao projeto e ao tutorial.

   Acessar a página Gerenciar recursos

3. Verifique se o faturamento foi ativado para o projeto.

   Saiba como ativar o faturamento

4. Ativar Compute Engine API.

   Ativar a a API

5. Instale e inicialize o SDK do Cloud.
6. Para ter uma conta do Fabric, faça a inscrição. Essa conta é usada pelo Fabric para distribuir versões de pré-lançamento (beta) do seu aplicativo para Android.
7. Verifique se o Gradle está instalado no computador.
8. Verifique se o Android Studio está instalado no computador.
9. Verifique se o Git está instalado no computador.

Neste tutorial, pressupomos que você:

• esteja executando o macOS ou o Linux. Alguns procedimentos estão adaptados a um ambiente Windows, mas o tutorial não fornece instruções completas para esse caso de uso;
• tenha alguma familiaridade com o desenvolvimento do Android, o Android Studio, o Gradle e o Git.

Conseguir que a versão beta assinada do Android esteja em execução no local

Nesta seção, você fará a configuração de um aplicativo para Android de teste no Android Studio. O aplicativo é criado e distribuído usando as tarefas de criação do Gradle, executadas na janela do terminal do computador.

Desenvolver um aplicativo de teste para Android para a versão

1. No Android Studio, crie um novo projeto Android que use uma atividade vazia.

   As capturas de tela abaixo mostram as etapas no assistente para executar essa tarefa.

   

   

   

   

2. Na janela do terminal do computador, mude para o diretório em que você criou o aplicativo de teste:

   cd ${HOME}/android-apps/TestAndroidBuild

3. Nesse diretório, inicialize um repositório Git:

   git init

4. Edite o arquivo .gitignore e adicione os nomes de arquivos e extensões que o Git não enviará ao seu repositório de código-fonte:

   cat >> .gitignore <<EOF
   *.jks
   fabric.properties
   keystore.properties
   EOF

5. Execute o commit do aplicativo no repositório:

   git add -A
   git commit -m "empty application"

6. Configure a ferramenta gcloud para usar seu projeto. Para o [PROJECT_NAME], use o nome do projeto selecionado ou criado.

   PROJECT = [PROJECT_NAME]
   gcloud config configurations create [PROJECT_NAME]
   gcloud config config set project [PROJECT_NAME]

7. Crie um repositório de origem da nuvem para o aplicativo para Android:

   gcloud source repos create android-application

8. Adicione o repositório de origem da nuvem como repositório remoto do aplicativo para Android:

   git remote add google \
       https://source.developers.google.com/p/${PROJECT}/r/android-application

Criar a chave de assinatura e keystore

Para distribuir o aplicativo para Android de pré-lançamento, você precisa assinar o aplicativo usando um certificado armazenado em um arquivo de keystore Java (.jks).

1. Na janela do terminal, altere para o diretório pai do aplicativo:

   cd ${HOME}/AndroidStudioProjects/TestAndroidBuild

2. Crie o keystore e a chave Java para assinar o aplicativo, bem como o arquivo keystore.properties que armazena o alias de chave, a senha e o caminho relativo para o arquivo keystore. Use este comando:

   JKS_PASSWORD=$(openssl rand -base64 12)
   keytool -genkey -noprompt -keystore android.jks \
     -alias android-key \
     -dname "CN=example.com, OU=IT, O=Example, L=Sunnyvale, S=California, C=US" \
     -storepass ${JKS_PASSWORD} \
     -keypass ${JKS_PASSWORD}
   
   cat > keystore.properties <<EOF
   storeFile=../android.jks #relative to the app/ directory
   storePassword=${JKS_PASSWORD}
   keyPassword=${JKS_PASSWORD}
   keyAlias=android-key
   EOF

3. Atualize o arquivo ${HOME}/AndroidStudioProjects/TestAndroidBuild/app/build.gradle com as propriedades de assinatura do aplicativo.

   Após as edições, o arquivo "Gradle" terá a seguinte aparência, com as alterações exibidas em negrito:

   def betaKeystorePropertiesFile = rootProject.file("keystore.properties")
   def keystoreProperties = new Properties()
   keystoreProperties.load(new FileInputStream(betaKeystorePropertiesFile));
   
   android {
   ...
      defaultConfig {...}
      signingConfigs {
          beta {
              keyAlias keystoreProperties['keyAlias']
              keyPassword keystoreProperties['keyPassword']
              storeFile file(keystoreProperties['storeFile'])
              storePassword keystoreProperties['storePassword']
          }
      }
      buildTypes {
          release {...}
          beta {
            initWith release
            signingConfig signingConfigs.beta
            ext.betaDistributionGroupAliases="testers"
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
          }
   }

Adicionar o Fabric para distribuição beta

1. Instale o plug-in do Fabric Android Studio.

2. No Android Studio, clique no ícone "Fabric" e siga as instruções do plug-in do Fabric para instalar o Crashlytics.

   

3. No Fabric, configure um grupo de distribuição de e-mail beta:

   1. No navegador, faça login na conta do Fabric.

   2. No lado esquerdo da tela, clique em Beta.

      

   3. Clique em Gerenciar Grupos e em Novo Grupo.

   4. Para o nome do grupo, digite testadores

   5. Na caixa de texto Adicionar testadores, digite um ou mais endereços de e-mail.

      

   6. Feche a janela.

Criar e distribuir o aplicativo a partir do seu computador

Na janela do terminal, certifique-se de estar no diretório de nível superior do seu aplicativo de teste e digite o seguinte:

gradle assembleBeta crashlyticsUploadDistributionBeta

Um e-mail é enviado para o grupo de distribuição com um link que permite ao usuário instalar o aplicativo.

Criar sua versão do Android no Cloud Build

A essa altura, você já tem tarefas de criação do Gradle em funcionamento. Elas são usadas para criar e distribuir seu aplicativo para Android. Nesta seção, você configura o Cloud Build para executar essas tarefas de criação sempre que houver uma alteração no branch mestre do Cloud Source Repository.

Fazer upload da assinatura do aplicativo e da chave secreta de distribuição

As tarefas de criação e distribuição usam o certificado armazenado em um arquivo de keystore Java (.jks) para assinar o aplicativo e uma chave da API Fabric para distribuir o aplicativo usando o Crashlytics. Não coloque credenciais em repositórios de código-fonte. Faça o upload dessas credenciais para um intervalo do Cloud Storage, assim o Android Builder fará o respectivo download no momento da criação e distribuição do aplicativo.

1. Na janela do terminal, altere para o diretório de nível superior do projeto do aplicativo para Android:

   cd ${HOME}/AndroidStudioProjects/TestAndroidBuild

2. Crie um intervalo do Cloud Storage para as chaves de assinatura do Android. Para [ANDROID_SIGNING_BUCKET], use um nome exclusivo. Para mais informações, veja as Diretrizes de nomenclatura de intervalos e objetos.

   gsutil mb gs://[ANDROID_SIGNING_BUCKET]

3. Copie os arquivos de distribuição .jks para esse intervalo:

   gsutil cp *.jks gs://[ANDROID_SIGNING_BUCKET]

4. Crie um intervalo do Cloud Storage para as chaves do Fabric. Para [FABRIC_KEYS_BUCKET], use um nome exclusivo.

   gsutil mb gs://[FABRIC_KEYS_BUCKET]

5. Copie o arquivo fabric.properties para esse intervalo:

   gsutil cp app/fabric.properties gs://[FABRIC_KEYS_BUCKET]

6. Crie o intervalo de armazenamento a ser usado pelo Android Builder para salvar as dependências entre criações:

   gsutil mb gs://[ANDROID_BUILD_CACHE]

Criar o Android Builder

1. Em uma janela de terminal, clone o repositório de criadores da comunidade em um diretório fora do diretório do aplicativo para Android:

   git clone https://github.com/GoogleCloudPlatform/cloud-builders-community

   O repositório do GitHub contém os criadores mantidos pela comunidade.

2. Altere para o diretório em que está o Android Builder:

   cd cloud-builders-community/android

3. Crie uma lista dos pacotes SDK para Android, necessários para suas criações e salve-a no diretório do criador como packages.txt. No arquivo, coloque cada pacote na respectiva linha.

   • Opção 1: Para gerar a lista a partir do seu computador, use este script:

     ./installed-package-list.sh

     Com isso, cada pacote do computador em que esse script estiver sendo executado é adicionado ao arquivo packages.txt. Como resultado, o arquivo packages.txt, gerado muitas vezes, inclui itens desnecessários para o contêiner de criação. A inclusão de componentes desnecessários aumenta os tempos de criação do aplicativo e do criador. Portanto, é recomendável que, após gerar o arquivo packages.txt, você o edite para incluir apenas os componentes do SDK necessários.

   • Opção 2: Crie o arquivo packages.txt manualmente. No exemplo a seguir, mostramos a aparência desse arquivo:

     extras;m2repository;com;android;support;constraint;constraint-layout;1.0.2
     extras;google;googleplayservices
     extras;android;gapid;3
     extras;google;auto
     extras;android;m2repository
     extras;google;webdriver
     platform-tools
     platforms;android-26

4. Na janela do terminal, salve a licença de SDK do Android em uma variável do shell:

   ANDROID_SDK_LICENSE=\
   $(tail -1 [ANDROID_SDK_HOME]/licenses/android-sdk-license)

   Substitua [ANDROID_SDK_HOME] pelo local apropriado para seu ambiente. Em um Mac, o [ANDROID_SDK_HOME] é normalmente ~/Library/Android/sdk. Em Linux, normalmente é ~/Android/Sdk.

5. Crie o Android Builder no projeto:

   gcloud builds submit --config cloudbuild.yaml . \
       --substitutions=_ANDROID_SDK_LICENSE=$ANDROID_SDK_LICENSE

Criar o acionador de criação do aplicativo para Android

Nesta seção, mostramos como criar o acionador de criação do aplicativo que usa o Android Builder da seção anterior para criar e distribuir o aplicativo para Android.

1. Na janela do terminal, copie o arquivo de exemplo cloudbuild.yaml da bifurcação da imagem base do Android para o diretório do aplicativo para Android de teste:

   cd ${HOME}/android-apps/TestAndroidBuild
   cp ${HOME}/cloud-builders-community/android
   android-cloud-build-example/fabric-beta-dist-cloudbuild.yaml ./cloudbuild.yaml

2. No Console do GCP, acesse a página Criar acionadores:

   Acessar a página Criar acionadores

3. Clique em Adicionar acionador.

4. Selecione a opção de hospedagem do repositório.
5. Selecione o repositório que você quer para acionar suas criações.
6. Digite um nome para o acionador de versão, por exemplo, minha versão do Android.
7. Na caixa Branch (regex), insira mestre. Neste tutorial, acione novas versões de aplicativos sempre que o código for mesclado para o branch mestre. Para saber detalhes sobre como adicionar acionadores de versão para atender às suas necessidades, consulte os documentos do Cloud Build.
8. Em Configuração da versão, selecione cloudbuild.yaml.
9. Em cloudbuild.yaml location, digite /cloudbuild.yaml.
10. Clique em Adicionar item. Isso permite configurar variáveis para a versão.

11. Para cada variável da tabela abaixo, digite o nome da variável (incluindo o sublinhado inicial) e o valor do seu projeto.

    Variável	Valor	Finalidade
    _ANDROID_SIGNING_BUCKET_PATH	O URL do intervalo criado para os arquivos .jks e keystore.properties. gs://[ANDROID_SIGNING_BUCKET]	Torna as credenciais de assinatura do Android disponíveis para a versão do Android no Cloud Build.
    _BUILD_TYPE	Beta	Especifica o tipo de criação do Gradle a ser usado para criar o aplicativo.
    _FABRIC_API_SECRET_BUCKET_PATH	O URL do intervalo que contém o arquivo fabric.properties: gs://[FABRIC_KEYS_BUCKET]	Fornece as credenciais da API Fabric para a versão do Android.
    _EMAIL_DISTRIBUTION_GROUP	O nome do grupo de distribuição de e-mail criado por você na interface do usuário do Fabric para distribuir versões beta.	Seleciona uma lista de endereços de e-mail em que a versão beta do aplicativo será distribuída pelo "Fabric".
    _ANDROID_BUILD_CACHE	O nome de um intervalo do Cloud Storage usado para armazenar dependências do "Gradle" entre versões.	Evita que o "Gradle" faça o download das mesmas dependências da internet em cada versão.
    _ANDROID_SDK_LICENSE	Sua licença do Android SDK	Verifica se você aceitou os termos da licença do SDK do Android.

Executar o acionador de versão do aplicativo

Agora é possível testar o funcionamento do acionador de versão do aplicativo e confirmar que o aplicativo foi distribuído para seu e-mail.

1. Em uma janela do terminal, altere os diretórios para o diretório de nível superior do projeto de teste do aplicativo para Android:

   cd ${HOME}/android-apps/TestAndroidBuild

2. Para acionar a versão, envie por push ao branch mestre do repositório do código-fonte:

   git push google master

3. No Console do GCP, acesse a página Cloud Build.

4. Clique na última versão em andamento para ver a saída dela para a versão do aplicativo.

Fazer limpeza

Após concluir o tutorial, é preciso limpar os recursos criados no GCP para não gerar faturamento. Nas próximas seções, mostraremos como excluir ou desativar esses recursos.

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:

Aviso: a exclusão de um projeto traz as seguintes consequências:

• Ao usar um projeto existente, qualquer outro trabalho feito no projeto será excluído.
• Você não conseguirá reutilizar o código de um projeto excluído. Caso tenha criado um código de projeto personalizado e planeje usá-lo no futuro, exclua os recursos desse projeto. Isso garante que os URLs que usam o código do projeto, como um URL do appspot.com, permaneçam disponíveis.

Ao explorar diversos tutoriais e guias rápidos, reutilize projetos em vez de excluí-los. Isso impedirá que os limites de cota do projeto sejam excedidos.

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

   Acessar a página Projetos

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

Excluir registros de imagens

Exclua os registros de imagem da imagem do SDK do Android e do aplicativo para Android.

1. No menu de navegação à esquerda do Console do GCP, role até a seção Ferramentas e clique em Container Registry > Imagens.

2. Selecione todas as imagens.

   

3. Clique em Excluir.

Excluir intervalos do Cloud Storage

Exclua os intervalos do Cloud Storage que contenham as informações de assinatura do Android e as propriedades do Fabric. No Cloud Shell, use esses comandos, substituindo os valores pelos marcadores:

gsutil rm gs://[ANDROID_SIGNING_BUCKET]
gsutil rm gs://[FABRIC_KEYS_BUCKET]
gsutil rm gs://[ANDROID_BUILD_CACHE]

Excluir os acionadores de versão

1. Exclua o acionador de versão de base do SDK do Android.
2. Exclua o acionador de versão do Android.

Excluir o aplicativo do Fabric

1. Faça o login no painel do Fabric e clique no ícone "Fabric" no canto superior esquerdo da tela:

   

2. Clique no bloco de aplicativos do painel:

   

3. Clique no ícone de configurações no canto superior direito do painel:

   

4. Clique no ícone Aplicativos:

   

5. Clique no bloco do aplicativo na lista:

   

6. Clique no link Excluir aplicativo no lado superior direito da página:

   

Próximas etapas

• Revise detalhadamente a documentação do Android.
• Analise detalhadamente a documentação do Firebase.