Azure DevOps — CI/CD de aplicações Android para iniciantes — Parte 1
A distribuição atual de aplicações à grande escala se faz necessária tanto quanto o seu próprio desenvolvimento. Entender que minutos valem ouro em processos repetitivos, de baixa confiabilidade da entender que deixar o trabalho manual de lado e partir para a automação desses processos se torna uma solução viável.
Claro que com isso vamos contar com algumas ferramentas, como a Azure devops e Google play console.
A partir de agora, tentarei ser o mais claro e explicativo possível a fim de passar minha experiência como iniciante e explorador ao mundo devops.
Chega de papo e vamos logo ao que interessa :D
Azure repos
Atualmente existem diversas ferramentas que nos ajudam a manter nossas aplicações, conhecido como controle de versão. Como por exemplo: Git, Tfs, entre outras. Como vamos utilizar de recursos da Azure devops para nossa automação, nada mal usar a ferramenta que essa stack da Microsoft nos fornece.
Se você já possuir um projeto no repos ou em outra plataforma pode ignorar esta etapa.
Após criar seu workspace no Azure devops, entre na aba Repos e faça o upload do seu projeto por meio do git. Segue aqui um passo a passo de como fazer isso.
Com o projeto em uma ferramenta de controle de versão que nos possibilite uma visão geral do que foi realizado e permita trabalhar com branches, e conceitos como Git flow, vamos partir para o que realmente interessa o CI da aplicação.
Azure pipelines
O Pipelines vai auxiliar o build do projeto para que seja possível gerar um APK que possibilite a distribuição para "centers" da escolha. Vou deixar meu projeto aqui como exemplo.
É possível realizar todo o CI e CD a partir do script Yaml, mas vamos explorar o máximo possível do que o Azure pipes nos fornece.
Vamos lá para o passo a passo da configuração.
Primeiramente, vá na aba pipeline como mostra na Imagem 1 e crie um novo pipeline. Após isso, selecione qual a ferramenta que você está utilizando como controle de versão, que no nosso caso é o Azure repos git.
Depois de selecionar sua opção, clique em qual projeto você deseja implementar o seu pipeline e, por fim, selecione como desejas configurar sua automação, como mostra a imagem a seguir:
Vamos seguir um pipeline com YAML conforme iremos configurar a partir daqui. Então deixe essa etapa aqui por um momento e continue a leitura.
Depois voltaremos à esta etapa.
Instrução YAML
Para entender um pouco melhor o que é e para que serve, uma breve introdução pode ser encontrada no site oficial da Yaml. Por aqui, seguiremos direto para a implementação.
Na raiz de seu projeto Android, adicione um arquivo chamado azure-pipe.yml e em seguida analise a implementação abaixo e veja para que cada uma dessas instruções serve.
# Indica quando esse pipe será ativado.trigger:
- main# Informa em qual SO seu pipe vai operar, como o android funciona em todos os sistemas, pode utilizar o da sua escolha.pool:
vmImage: 'windows-2019'# A partir daqui, os steps são os passos que seu pipe irá executar.steps:# Use esta tarefa para construir usando um script de wrapper Gradle. - task: Gradle@2
inputs:
workingDirectory: ''
gradleWrapperFile: 'gradlew'
tasks: 'build'
publishJUnitResults: false
javaHomeOption: 'JDKVersion'
gradleOptions: '-Xmx3072m'
Veja mais sobre argumentos da task Gradle aqui.
A segunda etapa vai ser útil para que seu projeto não tenha problemas ao ser publicado na play store, assinando seu APK. Para quem está familiarizado com Android sabe que existem assinaturas para aplicações publicadas na Play store e para isso temos uma task também.
Antes de ir para a configuração YAML, vamos precisar da assinatura do app que pode ser obtida pelo android studio em: build -> generate signed bundle/apk… -> android app bunlde ou apk -> create new
Apenas preencha os dados (não é necessário seguir a risca se for apenas um teste), e clique em ok. Após isso, seu arquivo JSON será gerado na pasta selecionada em key store path. Siga o artigo que logo vamos utilizá-lo.
# Use esta tarefa em um pipeline para assinar e alinhar arquivos Android APK.- task: AndroidSigning@3
inputs:
apkFiles: '**/*.apk'
apksignerKeystoreFile: 'key.store'
apksignerKeystorePassword: 'storepwd'
apksignerKeystoreAlias: 'key0'
apksignerKeyPassword: 'apppwd'
zipalign: false
A chave da store gerada acima, na Imagem 4, podem ser inseridas em uma funcionalidade que o Azure pipelines oferece para manter a segurança de dados sensíveis, com o intuito de não expor no código fonte.
Em Secure files você pode adicionar sua chave na opção +, upar seu arquivo JSON e colocá-lo como a seguir: apksignerKeystoreFile: ‘key.store’ como mostra na task AndroidSigning@3.
Demais chaves e alias podem ser configurados na tab variable groups, ou deixá-las estáticas conforme está no exemplo.
OBS: O zipalign me causou alguns problemas ao deixar ele como true. Muito depende da versão de seu projeto e de qual origem ele se destina. No meu caso, o zipalign se faz desnecessário deixando-o como false. Analise sua situação e entenda a fundo a real necessidade.
# Com nosso apk assinado e alinhado, vamos copiar arquivos de uma pasta de origem para uma pasta de destino usando padrões de correspondência.- task: CopyFiles@2
inputs:
SourceFolder: $(Build.SourcesDirectory)
contents: '**/*.apk'
targetFolder: '$(build.artifactStagingDirectory)'
overWrite: true
E por fim, vamos publicar artefatos de compilação no Azure Pipelines.
- task: PublishBuildArtifacts@1
displayName: 'Publish Artifact: drop'
inputs:
PathtoPublish: '$(build.artifactstagingdirectory)'Para as duas tasks acima é possível conhecer mais sobre os argumentos de CopyFiles e PublishBuildArtifacts em suas documentações oficiais.
Resumindo, o pipeline deve ficar assim:
trigger:
- mainpool:
vmImage: 'windows-2019'steps:
- task: Gradle@2
inputs:
workingDirectory: ''
gradleWrapperFile: 'gradlew'
tasks: 'build'
publishJUnitResults: false
javaHomeOption: 'JDKVersion'
gradleOptions: '-Xmx3072m'- task: AndroidSigning@3
inputs:
apkFiles: '**/*.apk'
apksignerKeystoreFile: 'key.store'
apksignerKeystorePassword: 'storepwd'
apksignerKeystoreAlias: 'key0'
apksignerKeyPassword: 'apppwd'
zipalign: false
- task: CopyFiles@2
inputs:
SourceFolder: $(Build.SourcesDirectory)
contents: '**/*.apk'
targetFolder: '$(build.artifactStagingDirectory)'
overWrite: true
- task: PublishBuildArtifacts@1
displayName: 'Publish Artifact: drop'
inputs:
PathtoPublish: '$(build.artifactstagingdirectory)'
Após finalizar, basta subir o arquivo para seu repositório master/main e voltar a configuração inicial da Imagem 3 acima, e escolher a opção Existing azure pipeline YAML file.
Selecione o path do seu arquivo YAML e clique em run.
Pronto. Seu pipeline vai pedir para você autorizar seu arquivo store antes de continuar:
Certifique-se de ser admin da sua conta Azure devops ou ter permissão para isso.
Basta permitir e está feito! Seu pipeline deve gerar um artefato como apresentado abaixo.
Se observar, há um link apontando 1 artefato gerado, se explorado conseguimos achar o APK de release e debug.
Para que este artigo não se estenda, darei continuidade à distribuição pela Play store (CD), na parte 2 deste artigo.
Bonus :D
Apesar de muito conteúdo na internet, acabei me deparando com diversos problemas e decidi pontuar alguns com suas devidas soluções.
Problema de autorização
Verifique sua task AndroidSigning@3 e veja se o arquivo JSON está relacionado corretamente, tanto via projeto quanto security files, como explicado. Veja os outros alias e senhas necessárias também.
Problema no zipalign
Sinceramente, não fui atrás para uma solução. Porém, li que a Google atualizou o SDK para Android, novas ferramentas de compilação que corrigem esse problema. Por isso, atualizando para o Android SDK Build-tools 20 resolveria. Também li em algum lugar (kkk) que não seria mais necessário em novos projetos, não confirmo veracidade de nenhum deles. No meu caso apenas deixei como false.
No geral é isso, espero que este artigo ajude você a atingir seus objetivos e fico a disposição de qualquer sugestão.
Ahh! não deixem de conferir a parte 2 e deixe o seu aplicativo 100% automatizado. Até a próxima.
