1. Antes de começar
Neste codelab, você vai aprender a usar o Firebase App Distribution e o plug-in fastlane dele para distribuir um app iOS para testadores, coletar UDIDs de dispositivos de teste e registrá-los no perfil de provisionamento do app para enviar rapidamente os builds Ad Hoc aos testadores.
Conteúdo
- Como fazer upload e distribuir um app iOS de pré-lançamento (Ad Hoc) para testadores usando o Firebase App Distribution e o fastlane.
- Como se inscrever como testador e fazer o download do app distribuído em um dispositivo de teste.
- Como registrar rapidamente dispositivos de teste exportando UDIDs de dispositivos de teste com o plug-in fastlane do App Distribution.
- Como atualizar o perfil de provisionamento do app e fazer upload dele novamente para distribuição.
Pré-requisitos
- Uma Conta do Google
- Uma máquina Apple com o XCode 11.7 ou superior instalado
- Um app iOS de pré-lançamento ad hoc integrado ao Xcode
- Uma conta de desenvolvedor da Apple paga
- Um dispositivo iOS físico para testes.
O app simulador para iOS vai funcionar na maior parte do codelab, mas os simuladores não podem fazer o download de versões.
Para verificar se a configuração funcionou, verifique se o botão "Fazer o download" aparece no app da Web do testador do App Distribution.
2. Comece já
Configurar o fastlane
O App Distribution se integra ao fastlane para permitir que você automatize a distribuição de builds de pré-lançamento do seu app. O App Distribution se integra à sua configuração do fastlane.
- Instale e configure o fastlane.
- Execute
fastlane init
no diretório raiz do projeto durante a configuração e escolha "Configuração manual". Você verá um subdiretório chamadofastlane
que contémFastfile
,Appfile
ePluginfile
, que você usará para configurar o fastlane.
instalar a CLI do Firebase
Também será necessário instalar a CLI do Firebase. Se você estiver usando macOS ou Linux, execute o seguinte comando cURL:
curl -sL https://firebase.tools | bash
Se você estiver usando o Windows, leia as instruções de instalação para receber um binário autônomo ou instalar via npm
.
Depois de instalar a CLI, a execução de firebase --version
precisará informar uma versão de 12.0.0
ou mais recente:
$ firebase --version 12.0.0
3. Criar seu app com o fastlane
Criar seu app
- Defina algumas variáveis globais para fastlane no seu
./fastlane/Appfile.
Inclua o ID do seu app e seu ID Apple:
app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")
- Crie sua primeira faixa e use a ação
build_app
do fastlane , também conhecida comogym
, para criar seu app adicionando o seguinte ao./fastlane/Fastfile
:
default_platform(:ios)
lane :build do
build_app(export_method: "ad-hoc")
end
- Assine seu app para distribuição.
Neste codelab, você vai gerenciar sua certificação e seu perfil usando o get_certificates
(também conhecido como cert
), que gera certificados de assinatura localmente e armazena tudo no seu conjunto de chaves do macOS. No entanto, é recomendável usar o fastlane sync_code_signing action
, também conhecido como match
, para gerenciar com segurança os perfis e os certificados de assinatura de código da sua equipe.
lane :build do
get_certificates()
build_app(export_method: "ad-hoc")
end
- Configure um perfil de provisionamento para seu app usando a ação
get_provisioning_profile
(também conhecida comosigh
). Isso permite que você compartilhe o app com testadores.
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true)
build_app(export_method: "ad-hoc")
end
- [Opcional] Se você nunca executou o aplicativo, execute o seguinte comando para criá-lo no Console para desenvolvedores da Apple:
$ fastlane produce --skip_itc
- Por fim, crie seu app executando a faixa.
Você será solicitado a seu ID Apple, senha (que está armazenada em seu Keychain) e ID do pacote do seu app.
$ fastlane build
Em caso de problemas, consulte o guia de solução de problemas do fastlane.
4. Fazer upload do app no Firebase
Agora que você criou seu app, está tudo pronto para fazer o upload dele para o App Distribution.
Criar e configurar um projeto do Firebase
- Faça login no Firebase.
- No Console do Firebase, crie ou adicione um novo projeto e o nomeie como "Codelab de exportação de UDID".
Você não precisa ativar o Google Analytics neste projeto.
- Clique em Criar projeto.
Adicionar seu app iOS ao projeto
- Clique no ícone do iOS para criar um novo app do Firebase para iOS e insira o ID do pacote.
- Pule as próximas etapas e clique em Continuar no console. Você vai adicionar SDKs ao app mais tarde.
Seu projeto e app agora estão disponíveis na página Visão geral do projeto.
Ativar o App Distribution
- Na seção "Versão e monitoramento", clique em App Distribution.
- Depois de aceitar os termos, clique em "Começar" para ativar o App Distribution no seu aplicativo.
Configurar uma distribuição no fastlane
- Execute o seguinte comando na raiz do seu projeto iOS para adicionar o App Distribution à sua configuração do fastlane.
Se o comando mostrar uma opção, selecione Opção 3: RubyGems.org:
$ fastlane add_plugin firebase_app_distribution
- Confirme se o plug-in está instalado:
$ fastlane
A saída vai mostrar fastlane-plugin-firebase_app_distribution
na lista de plug-ins instalados.
- Depois de confirmar que o plug-in está instalado, escolha a opção 0 para cancelar.
Autenticar seu projeto do Firebase
Para usar o plug-in fastlane, primeiro você precisa autenticar seu projeto do Firebase.
- Execute o seguinte comando para conectar a CLI à sua Conta do Google:
$ firebase login
- Quando o comando mostrar um link de autenticação, abra o link em um navegador.
- Quando solicitado, faça login na sua Conta do Google e conceda permissão para acessar seu projeto do Firebase.
Distribuir seu app
Agora está tudo pronto para a distribuição do app.
- Na parte de cima do
./fastlane/Fastfile
, defina uma variável com o nomefirebase_app_id
. Substitua<your_app_id>
pelo ID do app do Firebase referente ao aplicativo que você criou. É possível encontrar essa informação na página de configurações do projeto.
Como o Fastfile
é escrito em Ruby, use a sintaxe Ruby para definir variáveis.
firebase_app_id = "<your_app_id>"
- Adicione uma nova faixa com o nome
distribute
que chame a faixa de build e distribua seu app usando a açãofirebase_app_distribution
.
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
)
end
- Execute a nova faixa para criar seu app e criar uma distribuição.
$ fastlane distribute
Neste ponto, seu Fastfile ficará assim:
firebase_app_id = "<your Firebase app ID>"
default_platform(:ios)
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true)
build_app(export_method: "ad-hoc")
end
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
)
end
Depois de atualizar o console do Firebase, você verá a nova versão do aplicativo.
5. Convidar testadores para fazer o download do app
Quando um testador aceita um convite para testar um build ad hoc, é solicitada a permissão para compartilhar o UDID. Se eles concordarem, o App Distribution vai coletar as informações do dispositivo e notificar você por e-mail. Nesta seção, você vai se adicionar como testador para fazer o download e testar o app distribuído.
Adicionar seu perfil como testador da versão
- Em
firebase_app_id
, na parte de cima do Fastfile, crie uma variável para armazenar os testadores e inclua seu próprio endereço de e-mail e outros endereços de e-mail opcionais que você queira testar.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
- Aplique o método Array#join do Ruby para transformar a matriz
app_testers
em uma string separada por vírgulas, conforme é esperada pelo parâmetrotesters
. Em seguida, transmita o resultado para o parâmetrotesters
defirebase_app_distribution.
.
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!"
testers: app_testers.join(","),
)
end
Neste ponto, seu Fastfile ficará assim:
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
default_platform(:ios)
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true)
build_app(export_method: "ad-hoc")
end
lane :distribute do
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
testers: app_testers.join(","),
)
end
- Siga a faixa de novo.
$ fastlane distribute
Depois de executar a faixa, os testadores adicionados vão receber um e-mail de convite do App Distribution notificando sobre a nova versão. No Console do Firebase, agora é possível ver os testadores adicionados à versão do app.
Como você incluiu seu endereço de e-mail, receberá um e-mail do Firebase App Distribution com um convite para testar o aplicativo. Agora você é o primeiro testador. Continue na seção abaixo para configurar como testador no dispositivo de teste.
Registrar o dispositivo de teste
Como testador, você precisará fazer login no Google no seu dispositivo de teste para acessar as versões do app que foi convidado a testar. Como sua versão de teste é uma versão ad hoc, também será necessário registrar o dispositivo de teste instalando o perfil do Firebase. Depois disso, as versões vão poder ser acessadas no app da Web para testadores do App Distribution usando o clipe da Web adicionado à tela inicial do dispositivo.
- No dispositivo de teste iOS, abra o e-mail enviado pelo Firebase App Distribution e toque no link Começar. Abra o link no Safari.
- Você está no app da Web para testadores do App Distribution. Na página exibida, faça login com sua Conta do Google e toque em Aceitar convite.
- Agora é possível conferir os lançamentos para os quais você recebeu um convite. Toque em Registrar dispositivo em uma das versões.
- Quando solicitado, faça o download do perfil do Firebase e instale-o no app Configurações.
A instalação do perfil concede ao Firebase permissão para:
- Registre o dispositivo de teste coletando o ID exclusivo do dispositivo (UDID).
O Firebase envia a todos os proprietários e editores do projeto do Firebase um e-mail que inclui o UDID do dispositivo de teste.
- Instale um clipe da Web na tela inicial do dispositivo de teste. O clipe da Web abre o app da Web do testador do App Distribution, que permite instalar e acessar todos os apps de teste.
No app da Web para testadores do App Distribution, seu dispositivo de teste agora está registrado para a versão do app.
Agora que você compartilhou o UDID do seu dispositivo de teste com o Firebase, já pode retomar o papel de desenvolvedor. Na guia "Testadores" do painel do App Distribution, as informações do testador agora aparecem na versão do app com o status "Aceito":
Na próxima seção, você vai adicionar o UDID do dispositivo ao perfil de provisionamento do app e criar uma versão dele que funcione com o dispositivo de teste.
Exportar UDIDs do dispositivo de teste
Como desenvolvedor, você receberá um e-mail do Firebase com o UDID do dispositivo de teste. Como opção, o App Distribution facilita a coleta de vários UDIDs de dispositivos novos de uma só vez, permitindo exportá-los diretamente do Console do Firebase como um arquivo de texto bruto.
- Para exportar todos os UDIDs, abra a guia Testadores e grupos.
- Clique em Exportar UDIDs da Apple.
Esse arquivo precisa conter o UDID do dispositivo de teste.
Device ID Device Name Device Platform
1234567890 udid.codelab.tester@gmail.com - iPhone SE 2nd Gen ios
Os UDIDs também podem ser exportados a partir da linha de comando usando o fastlane, o que você fará na próxima seção.
6. Atualizar e recriar o perfil de provisionamento do app
Agora, adicione o UDID do dispositivo de teste ao perfil de provisionamento do app, recrie uma versão do app que funcione no dispositivo e distribua a nova versão.
Adicionar faixa de exportação de UDID
- Adicione outra variável na parte superior do Fastfile e defina-a como um caminho de arquivo em que os UDIDs dos dispositivos dos testadores serão transferidos.
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
tester_udids_file = "tester_udids.txt"
- Configure uma nova faixa que use a ação de exportação UDID do plug-in do App Distribution para fazer o download dos UDIDs do testador, como você fez no console.
lane :download_udids do
firebase_app_distribution_get_udids(
app: firebase_app_id,
output_file: tester_udids_file,
)
end
- Execute a seguinte faixa para fazer o download dos UDIDs.
$ fastlane download_udids
- Imprima o arquivo salvo, que deve conter os UDIDs do dispositivo de teste.
$ cat tester_udids.txt
Adicionar dispositivos ao Console para desenvolvedores da Apple
- Crie a seguinte faixa para adicionar os UDIDs à sua lista de dispositivos no Console para desenvolvedores da Apple e adicioná-los ao seu perfil de provisionamento usando a ação
register_devices
do fastlane :
lane :add_new_devices do
register_devices(devices_file: tester_udids_file)
end
- Em seguida, execute a faixa:
$ fastlane add_new_devices
Os novos dispositivos vão aparecer na lista de dispositivos do console do desenvolvedor.
Adicionar dispositivos ao seu perfil de provisionamento
- Adicione o argumento
force
à etapa do perfil de provisionamento na faixabuild
para forçá-lo a coletar novos dispositivos sempre que você criar.
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true, force: true)
build_app(export_method: "ad-hoc")
end
Executar a faixa novamente para criar e fazer upload
Agora, você vai atualizar a faixa distribute
com as novas para adicionar os dispositivos ao perfil de provisionamento, recriar o app e distribuí-lo.
- Chame as novas faixas em
distribute
:
lane :distribute do
download_udids
add_new_devices
build
firebase_app_distribution(
app: "1:123456789:ios:abcd1234",
release_notes: "Try out this app!"
testers: app_testers.join(","),
)
end
- Execute a faixa
distribute
:
$ fastlane distribute
Neste ponto, seu Fastfile ficará assim:
firebase_app_id = "<your Firebase app ID>"
app_testers = [
"your@email.com",
"another@email.com",
]
tester_udids_file = "tester_udids.txt"
default_platform(:ios)
lane :build do
get_certificates()
get_provisioning_profile(adhoc: true, force: true)
build_app(export_method: "ad-hoc")
end
lane :distribute do
download_udids
add_new_devices
build
firebase_app_distribution(
app: firebase_app_id,
release_notes: "Try out this app!",
testers: app_testers.join(","),
)
end
lane :download_udids do
firebase_app_distribution_get_udids(
app: firebase_app_id,
output_file: tester_udids_file,
)
end
lane :add_new_devices do
register_devices(devices_file: tester_udids_file)
end
Fazer o download da versão no dispositivo de teste
Agora que seu app inclui os UDIDs do dispositivo de teste, eles podem ser instalados nesses dispositivos.
- No dispositivo de teste, volte ao app da Web para testadores do App Distribution usando o link enviado por e-mail ou o ícone na tela inicial do dispositivo.
Ao navegar até o app do codelab da UDID, você verá que a versão está pronta para download.
- Se você estiver em um dispositivo físico, pressione "Download" e instale e execute o app.
7. Parabéns
Você configurou o App Distribution e o fastlane para automatizar o processo de teste de pré-lançamento. Agora, quando quiser convidar mais testadores ou adicionar os UDIDs deles ao app, execute apenas um comando: fastlane distribute
.
Assim você não precisa mais coletar UDIDs de testadores individualmente nem acessar o console para desenvolvedores da Apple para atualizar listas de dispositivos ou perfis de provisionamento. Você nem precisa abrir o XCode!
Esse fluxo de trabalho é fácil de configurar para ser executado a cada hora ou diariamente no seu ambiente de integração contínua.
Sugestões de leitura
- Conheça os recursos do Firebase App Distribution, incluindo nosso SDK no app para iOS
- Saiba mais sobre o fastlane
- Gerencie a assinatura de código da sua equipe com o
match
- Integre o fastlane à sua CI