Distribua suas compilações iOS de pré-lançamento mais rapidamente com App Distribution e fastlane

1. Antes de começar

Neste codelab, você aprenderá a usar o Firebase App Distribution e seu plug-in fastlane para distribuir um aplicativo iOS para testadores, coletar UDIDs de dispositivos de teste e registrá-los no perfil de provisionamento do seu aplicativo, para que você possa obter compilações ad hoc rapidamente nos testadores ' mãos.

O que você aprenderá

• Como fazer upload e distribuir um aplicativo iOS de pré-lançamento (Ad Hoc) para testadores usando Firebase App Distribution e fastlane .
• Como se inscrever como testador e baixar o aplicativo 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 seu aplicativo e carregá-lo novamente para distribuição.

O que você precisará

• Uma conta do Google
• Uma máquina Apple com XCode 11.7+ instalado
• Um aplicativo iOS de pré-lançamento Ad Hoc criado no Xcode
• Uma conta paga de desenvolvedor Apple
• Um dispositivo iOS físico para teste.

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

Você ainda pode verificar se a configuração funcionou verificando se o botão "Download" aparece no aplicativo da web do testador de distribuição de aplicativos.

2. Comece

Configurar via rápida

O App Distribution integra-se ao fastlane para permitir que você automatize a distribuição de compilações de pré-lançamento do seu aplicativo. O App Distribution integra-se à sua configuração fastlane .

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

Instale a CLI do Firebase

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

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

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

Depois de instalar a CLI, executar firebase --version deverá reportar uma versão 12.0.0 ou superior:

$ firebase --version
12.0.0

3. Crie seu aplicativo com fastlane

Crie seu aplicativo

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

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

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

default_platform(:ios)

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

3. Assine seu aplicativo para distribuição.

Neste codelab, você gerenciará sua própria certificação e perfil usando get_certificates (também conhecido como cert ), que gera certificados de assinatura localmente e armazena tudo nas Chaves do macOS. Normalmente, no entanto, você desejará usar a ação fastlane sync_code_signing action (também conhecida como match ) para gerenciar com segurança os certificados e perfis 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 aplicativo usando a ação get_provisioning_profile (também conhecida como sigh ). Isso permite que você compartilhe seu aplicativo 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 seu aplicativo antes, execute o seguinte comando para criar seu aplicativo no console do desenvolvedor Apple:

$ fastlane produce --skip_itc

6. Por fim, crie seu aplicativo executando a pista.

Serão solicitados seu ID Apple, senha (que está armazenada em suas Chaves) e o ID do pacote do seu aplicativo.

$ fastlane build

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

4. Faça upload do seu aplicativo para o Firebase

Agora que você criou seu aplicativo, está pronto para carregá-lo no App Distribution.

Crie e configure 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 para este projeto.

3. Clique em Criar projeto .

Adicione seu aplicativo iOS ao projeto

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

2. Pule as próximas etapas e clique em Continuar para console . Você adicionará SDKs ao seu aplicativo posteriormente.

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

Habilitar distribuição de aplicativos

1. Na seção Liberar e monitorar, clique em Distribuição de aplicativos .
2. Depois de aceitar os termos, clique em "Começar" para ativar o App Distribution para seu aplicativo.

Configure uma distribuição no fastlane

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

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

$ fastlane add_plugin firebase_app_distribution

2. Confirme se o plugin está instalado:

$ fastlane

A saída deve mostrar fastlane-plugin-firebase_app_distribution na lista de plugins instalados.

3. Após confirmar que o plugin está instalado, escolha a opção 0 para cancelar.

Autentique seu projeto do Firebase

Para usar o plug-in fastlane , primeiro você autenticará seu projeto do Firebase.

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 link em um navegador.
3. Quando solicitado, faça login na sua Conta do Google e conceda permissão para acessar seu projeto do Firebase.

Distribua seu aplicativo

Agora você está pronto para distribuir seu aplicativo.

1. Na parte superior do seu ./fastlane/Fastfile , defina uma variável chamada firebase_app_id . Substitua <your_app_id> pelo Firebase App ID do aplicativo que você criou (isso pode ser encontrado na página de configurações do projeto ).

O Fastfile é escrito em Ruby, então use a sintaxe Ruby para definir variáveis.

firebase_app_id = "<your_app_id>"

2. Adicione uma nova via chamada distribute que chama a via de construção e, em seguida, distribui seu aplicativo 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 via para construir seu aplicativo e criar uma distribuição.

$ fastlane distribute

Neste ponto, seu Fastfile deve ter a seguinte 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 seu aplicativo.

5. Convide testadores para baixar seu aplicativo

Quando um testador aceita um convite para testar uma compilação Ad Hoc, ele recebe permissão para compartilhar seu UDID. Se eles concordarem, o App Distribution coleta as informações do dispositivo e notifica você por e-mail. Nesta seção, você se adicionará como testador para baixar e testar o aplicativo distribuído.

Adicione-se como testador do lançamento

1. Em firebase_app_id na parte superior do seu Fastfile, crie uma variável para armazenar testadores e inclua seu próprio endereço de e-mail, bem como outros endereços de e-mail opcionais que você gostaria de experimentar.

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

2. Aplique o método Array#join do Ruby para transformar o array app_testers em uma string separada por vírgula, que o parâmetro testers espera. Em seguida, passe o resultado para o 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, seu Fastfile deve ficar assim:

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. Execute a pista novamente.

$ fastlane distribute

Depois de executar a pista, os testadores adicionados receberão um e-mail de convite do App Distribution notificando-os sobre o novo lançamento disponível. No console do Firebase, agora você pode ver os testadores adicionados na versão do seu aplicativo.

Como você incluiu seu endereço de e-mail, receberá um e-mail do Firebase App Distribution convidando você para testar o aplicativo. Você agora é o primeiro testador! Continue a seção abaixo para configurar como testador em seu dispositivo de teste.

Registre seu dispositivo de teste

Como testador, você precisará fazer login no Google em seu dispositivo de teste para acessar as versões de aplicativos para as quais 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. Posteriormente, as versões disponibilizadas para você poderão ser acessadas no aplicativo da web do testador do App Distribution, usando o web clip adicionado à tela inicial do seu dispositivo.

1. No seu dispositivo de teste iOS, abra o e-mail enviado pelo Firebase App Distribution e toque no link Primeiros passos . Certifique-se de abrir o link no Safari.
2. Agora você está no aplicativo da web do testador de distribuição de aplicativos. 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 foi convidado. Toque em Registrar dispositivo em uma das versões.

4. Quando solicitado, baixe o perfil do Firebase e instale-o no aplicativo Configurações.

A instalação do perfil dá permissão ao Firebase 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 web clip na tela inicial do dispositivo de teste. O web clip abre o aplicativo web do testador de distribuição de aplicativos, que permite instalar e acessar todos os seus aplicativos de teste.

No aplicativo Web do testador do App Distribution, seu dispositivo de teste agora está registrado para o lançamento do seu aplicativo.

Observação: se você já adicionou este dispositivo à sua conta de desenvolvedor no passado, ele já pode ter sido incluído no perfil de provisionamento e você já verá um botão "Download" aqui.

Agora que você compartilhou o UDID do seu dispositivo de teste com o Firebase, você pode retomar como desenvolvedor. Na guia Testadores do painel de distribuição de aplicativos , as informações do testador agora aparecem na versão do seu aplicativo com o status "Aceito":

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

Exporte os UDIDs do seu dispositivo testador

Como desenvolvedor, você receberá um e-mail do Firebase contendo o UDID do dispositivo de teste. Como opção, o App Distribution facilita a coleta de vários UDIDs de novos 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 deve 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 da linha de comando usando fastlane , o que você fará na próxima seção.

6. Atualize o perfil de provisionamento do seu aplicativo e reconstrua-o

Agora, você adicionará o UDID do seu dispositivo de teste ao perfil de provisionamento do seu aplicativo, reconstruirá uma versão do seu aplicativo que funcione para o seu dispositivo e distribuirá a nova versão.

Adicionar pista de exportação UDID

1. Adicione outra variável na parte superior do seu Fastfile e defina-a como um caminho de arquivo onde os UDIDs dos dispositivos dos seus testadores serão baixados.

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

2. Configure uma nova pista que use a ação de exportação de UDID do plug-in App Distribution para baixar os 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 seguinte pista para baixar os UDIDs.

$ fastlane download_udids

4. Imprima o arquivo baixado, que deve conter os UDIDs do dispositivo de teste.

$ cat tester_udids.txt

Adicione dispositivos ao console do desenvolvedor Apple

1. Crie a seguinte pista para adicionar os UDIDs à ​​sua lista de dispositivos no console do desenvolvedor da Apple, para que você possa 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

2. Então, execute a pista:

$ fastlane add_new_devices

Você deverá então ver os novos dispositivos na lista de dispositivos do console do desenvolvedor.

Adicione dispositivos ao seu perfil de provisionamento

1. Adicione o argumento force à etapa do perfil de provisionamento em sua rota build , para forçá-lo a selecionar 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

Execute novamente a pista para construir e fazer upload

Agora, você atualizará sua pista distribute com as novas pistas para adicionar os dispositivos ao perfil de provisionamento, reconstruir o aplicativo e, em seguida, distribuí-lo.

1. Chame as novas pistas 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 pista distribute :

$ fastlane distribute

Neste ponto, seu Fastfile deve ficar assim:

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

Baixe a versão do dispositivo de teste

Agora que seu aplicativo inclui os UDIDs do dispositivo de teste, eles podem ser instalados nos dispositivos de teste.

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

Ao navegar até o aplicativo codelab UDID, você verá que a versão está pronta para download.

2. Se você estiver em um dispositivo físico, pressione download, instale e execute o aplicativo!

Observação: os downloads de versões só funcionam em dispositivos físicos. Se você estiver em um simulador, o download não funcionará, mas você ainda poderá verificar se a configuração funcionou verificando se o botão "Download" aparece no aplicativo da web do testador de distribuição de aplicativos.

7. Parabéns

Agora você configurou o App Distribution e o fastlane para automatizar seu processo de teste de pré-lançamento. Agora, quando quiser convidar testadores adicionais ou adicionar seus UDIDs ao seu aplicativo, você só precisará executar um comando: fastlane distribute .

Portanto, não é mais necessário coletar UDIDs individualmente dos testadores ou acessar o console do desenvolvedor da Apple para atualizar listas de dispositivos ou provisionar perfis. Você nem precisa abrir o XCode!

Esse fluxo de trabalho é fácil de configurar para ser executado de hora em hora ou diariamente em seu ambiente de integração contínua.

Leitura adicional

• Explore os recursos do Firebase App Distribution , incluindo nosso SDK no aplicativo para iOS
• Saiba mais sobre Fastlane
• Gerencie a assinatura de código da sua equipe com match
• Integre o fastlane ao seu CI