Distribua seus builds de pré-lançamento para iOS mais rapidamente com o App Distribution e o fastlane

1. Antes de começar

Neste codelab, você vai aprender a usar o Firebase App Distribution e o plug-in fastlane para distribuir um app iOS aos testadores, coletar UDIDs do dispositivo de teste e registrá-los no perfil de provisionamento do app. Assim, você tem acesso rápido aos builds ad hoc.

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 dispositivos de teste rapidamente exportando UDIDs do dispositivo de teste com o plug-in fastlane do App Distribution.
• Como atualizar o perfil de provisionamento do seu app e fazer um novo upload para distribuição

Pré-requisitos

• Uma Conta do Google
• Uma máquina Apple com o XCode 11.7+ instalado
• Um app iOS de pré-lançamento ad hoc criado no Xcode
• Uma conta paga de desenvolvedor da Apple
• Um dispositivo físico com iOS para testes

O app simulador para iOS funcionará na maior parte do codelab, mas os simuladores não podem fazer o download de versões.

Você ainda pode verificar se a configuração funcionou verificando 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 é integrado ao fastlane para permitir que você automatize a distribuição de builds de pré-lançamento do seu app. Ele se integra à sua configuração do fastlane.

1. Instale e configure o fastlane.
2. Execute fastlane init no diretório raiz do projeto durante a configuração e escolha "Configuração manual". Você verá um subdiretório chamado fastlane que contém um Fastfile, Appfile e Pluginfile, que você usará para configurar o fastlane.

instalar a CLI do Firebase

Você também precisará instalar a CLI do Firebase. Se estiver usando macOS ou Linux, você poderá executar o seguinte comando cURL:

curl -sL https://firebase.tools | bash

Se você estiver usando o Windows, leia as instruções de instalação para instalar um binário autônomo ou via npm.

Depois de instalar a CLI, a execução de firebase --version 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

1. Defina algumas variáveis globais para fastlane no seu ./fastlane/Appfile.. Inclua o ID do app e seu ID Apple:

app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")

2. Crie sua primeira faixa e use a ação build_app do fastlane (também conhecida como gym) para criar seu app adicionando o seguinte ao seu ./fastlane/Fastfile:

default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end

3. 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, normalmente é recomendado usar o fastlane sync_code_signing action (também conhecido como match) para gerenciar com segurança os perfis e certificados de assinatura de código da sua equipe.

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end

4. Configure um perfil de provisionamento para seu app usando a ação get_provisioning_profile (também conhecida como sigh). Ela permite compartilhar o app com testadores.

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

5. [Opcional] Se você nunca executou o aplicativo antes, execute o seguinte comando para criá-lo no console do desenvolvedor da Apple:

$ fastlane produce --skip_itc

6. Por fim, crie o app executando a faixa.

Você será solicitado a inserir seu ID Apple, sua senha (armazenada no seu Keychain) e o ID do pacote do seu app.

$ fastlane build

Se você tiver algum problema, consulte o guia de solução de problemas do fastlane.

4. Fazer upload do seu app no Firebase

Agora que você criou seu app, está tudo pronto para fazer upload dele no App Distribution.

Criar e configurar um projeto do Firebase

1. Faça login no Firebase.
2. No Console do Firebase, crie ou adicione um novo projeto e nomeie-o como "UDID Export Codelab".

Você não precisa ativar o Google Analytics neste projeto.

3. Clique em Criar projeto.

Adicionar o app iOS ao projeto

1. Clique no ícone do iOS para criar um novo app iOS do Firebase e insira o ID do pacote do seu app.

2. Pule as próximas etapas e clique em Continuar no console. Você vai adicionar SDKs ao app mais tarde.

Seu projeto e aplicativo agora estão disponíveis na página Visão geral do projeto.

Ativar o App Distribution

1. Na seção "Versão e monitoramento", clique em App Distribution.
2. Depois de aceitar os termos, clique em "Começar" para ativar o App Distribution para seu app.

Configurar uma distribuição no fastlane

1. Execute o seguinte comando na raiz do seu projeto iOS para adicionar o App Distribution à sua configuração de fastlane.

Se o comando exibir uma opção, selecione Opção 3: RubyGems.org:

$ fastlane add_plugin firebase_app_distribution

2. Confirme se o plug-in está instalado:

$ fastlane

A saída vai mostrar fastlane-plugin-firebase_app_distribution na lista de plug-ins instalados.

3. 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, seu projeto do Firebase será autenticado primeiro.

1. Execute o seguinte comando para conectar a CLI à sua Conta do Google:

$ firebase login

2. Quando o comando imprimir um link de autenticação, abra-o em um navegador.
3. 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 distribuir seu app.

1. Na parte de cima do ./fastlane/Fastfile, defina uma variável com o nome firebase_app_id. Substitua <your_app_id> pelo ID do app do Firebase que você criou. Ele pode ser encontrado na página de configurações do projeto.

O Fastfile é escrito em Ruby. Portanto, use a sintaxe do Ruby para definir variáveis.

firebase_app_id = "<your_app_id>"

2. Adicione uma nova faixa com o nome distribute, que chama a faixa de build e distribui o app usando a ação firebase_app_distribution.

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end

3. Execute a nova faixa para criar seu app e criar uma distribuição.

$ fastlane distribute

Neste ponto, o Fastfile terá esta aparência:

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 app.

5. Convidar testadores para fazer o download do app

Quando um testador aceita um convite para testar uma versão ad hoc, é solicitada permissão para compartilhar o UDID dele. Se ele concordar, o App Distribution coletará as informações do dispositivo dele e notificará você por e-mail. Nesta seção, você vai se adicionar como testador para fazer o download e testar o app que distribuiu.

Participar como testador da versão

1. Em firebase_app_id, na parte de cima do Fastfile, crie uma variável para colocar os testadores e inclua seu próprio endereço de e-mail, além de outros endereços de e-mail opcionais que você quiser testar.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

2. Aplique o método Array#join do Ruby para transformar a matriz app_testers em uma string separada por vírgulas, esperada pelo parâmetro testers. Em seguida, transmita o resultado ao parâmetro testers de firebase_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, o Fastfile terá esta aparência:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

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

3. Corra pela 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 disponível. No Console do Firebase, agora é possível ver os testadores adicionados na versão do app.

Como você incluiu seu endereço de e-mail, vai receber um e-mail do Firebase App Distribution com um convite para testar o app. Agora você é o primeiro testador. Continue a seção abaixo para se preparar como um 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 de apps que foi convidado a testar. Como seu build de teste é uma versão ad hoc, você também precisará registrar seu dispositivo de teste instalando o perfil do Firebase. Depois disso, as versões disponíveis poderão ser acessadas no app da Web para testadores do App Distribution usando o clipe da Web adicionado à tela inicial do dispositivo.

1. No dispositivo de teste iOS, abra o e-mail enviado pelo Firebase App Distribution e toque no link Vamos começar. Abra o link no Safari.
2. Agora você está no app da Web do testador do App Distribution. Na página que aparece, faça login com sua Conta do Google e toque em Aceitar convite.

3. Agora você pode ver os lançamentos para os quais recebeu convite. Toque em Registrar dispositivo em uma das versões.

4. 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.

• Instalar 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 do testador do App Distribution, seu dispositivo de teste agora está registrado para a versão do app.

Observação:se você já tiver adicionado o dispositivo à sua conta de desenvolvedor, talvez ele já tenha sido incluído no perfil de provisionamento, e o botão "Fazer o download" já vai aparecer aqui.

Agora que você compartilhou o UDID do seu dispositivo de teste com o Firebase, pode continuar como desenvolvedor. Na guia Testadores do painel do App Distribution, as informações do testador agora aparecem abaixo da versão do app com o status "Aceito":

Na próxima seção, você adicionará o UDID do dispositivo ao perfil de provisionamento do seu app e, em seguida, criará uma versão do app que funcione com o dispositivo de teste.

Exportar os UDIDs do dispositivo de testador

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 novos UDIDs de dispositivos de uma só vez, permitindo exportá-los diretamente do Console do Firebase como um arquivo de texto bruto.

1. Para exportar todos os UDIDs, abra a guia Testadores e grupos.

2. Clique em Exportar UDIDs da Apple.

O arquivo precisa conter o UDID do seu dispositivo de teste.

Device ID            Device Name                            Device Platform
1234567890     [e-mail] - iPhone SE 2nd Gen        ios

Os UDIDs também podem ser exportados pela linha de comando usando o fastlane. Isso será feito na próxima seção.

6. Atualizar e recriar o perfil de provisionamento do app

Agora, você vai adicionar o UDID do dispositivo de teste ao perfil de provisionamento do app, recriar uma versão do app que funcione no dispositivo e distribuir a nova versão.

Adicionar lane de exportação de UDID

1. Adicione outra variável na parte superior do Fastfile e a defina como um caminho de arquivo em que será feito o download dos UDIDs dos dispositivos dos testadores.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
tester_udids_file = "tester_udids.txt"

2. Configure uma nova linha que use a ação de exportação de UDID do plug-in do App Distribution para fazer o download dos UDIDs do testador, assim como você fez no console.

lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end

3. Execute a faixa a seguir para fazer o download dos UDIDs.

$ fastlane download_udids

4. Imprima o arquivo transferido por download, que precisa conter os UDIDs do dispositivo de teste.

$ cat tester_udids.txt

Adicionar dispositivos ao console do desenvolvedor da Apple

1. Crie a linha a seguir para adicionar os UDIDs à lista de dispositivos no Console para desenvolvedores da Apple e adicioná-los ao perfil de provisionamento usando a ação register_devices do fastlane :

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

2. Depois, execute a faixa:

$ fastlane add_new_devices

Você verá os novos dispositivos na lista de dispositivos do console do desenvolvedor.

Adicionar dispositivos ao seu perfil de provisionamento

1. Adicione o argumento force à etapa do perfil de provisionamento na linha build para forçá-lo a escolher 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ê atualizará a faixa distribute com as novas faixas para adicionar os dispositivos ao perfil de provisionamento, recriar o app e distribuí-lo.

1. Chame as novas faixas de 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

2. Execute a faixa distribute:

$ fastlane distribute

Neste ponto, o Fastfile terá esta aparência:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
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

Faça o download da versão no dispositivo de teste

Agora que o app inclui os UDIDs do dispositivo de teste, eles podem ser instalados neles.

1. No dispositivo de teste, retorne ao app da Web do testador do App Distribution usando o link no e-mail ou o ícone na tela inicial do dispositivo.

Ao navegar até o app do codelab da UDID, você vai notar que a versão está pronta para download.

2. Se você estiver usando um dispositivo físico, pressione "Download" e instale e execute o app.

Observação:os downloads de versões só funcionam em dispositivos físicos. Se você estiver em um simulador, o download não vai funcionar, mas ainda será possível verificar se a configuração funcionou verificando se o botão "Fazer o download" aparece no app da Web do testador do App Distribution.

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 outros testadores ou adicionar os UDIDs deles ao app, você só vai precisar executar um comando: fastlane distribute.

Não é mais necessário coletar UDIDs individualmente de testadores nem acessar o console do desenvolvedor 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 em 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
• Integrar o fastlane à sua CI