Liberar um build

Carregue o pacote binário do aplicativo no App Center para distribuí-lo. O App Center dá suporte à distribuição de pacotes para aplicativos android, iOS, macOS, Windows e sistema operacional personalizado. Você pode distribuir versões para testadores individuais ou grupos de testadores. Para aplicativos iOS e Android, você também pode liberar para as lojas como o Google Play, a App Store e o Intune. Consulte Publicar em lojas empresariais e para consumidores.

Nesta página, você pode aprender a gerar o binário para lançamento e como carregá-lo e liberá-lo em grupos usando o portal, a CLI (interface de linha de comando) e a API (interface de programação do aplicativo).

Você também pode usar o Azure DevOps ou o Jenkins:

• O Azure DevOps usa a Tarefa de Distribuição do App Center (versão 3+)
• Plug-in jenkins (versão 0.11.0+).

Gerando um pacote binário de aplicativo

Primeiro, você deve empacotar seu aplicativo em um arquivo binário para lançamento. Você pode criar esse arquivo manualmente.

As seções a seguir explicam como criar os arquivos para todos os tipos de aplicativo compatíveis com o App Center para distribuição.

Android

Para Android, você deve produzir um pacote de aplicativo assinado ou um arquivo APK. Para obter detalhes completos desse processo, consulte a documentação oficial do Google sobre como preparar um aplicativo para lançamento.

1. Verifique se você atualizou o manifesto e tem um build do Gradle configurado corretamente.
2. No Android Studio, escolha Build>Generate Signed Bundle/APK e siga as etapas no assistente para criar o pacote de aplicativos ou o APK.

O Android Studio coloca pacotes de aplicativos criados em project-name/module-name/build/outputs/bundle/ e APKs em project-name/module-name/build/outputs/apk/.

iOS

Para iOS, você deve produzir um pacote IPA para seu aplicativo. Para obter detalhes completos desse processo, consulte a documentação oficial da Apple.

1. Registre UDIDs para todos os dispositivos de hardware em seu perfil de provisionamento.
2. No Xcode, vá para o Arquivo de Produto> para arquivar seu aplicativo.
3. Exporte o pacote usando o perfil de provisionamento adequado.

macOS

Para macOS, você deve produzir um pacote de aplicativo. O App Center dá suporte à liberação de pacotes de aplicativos do tipo .app.zip, .pkg ou .dmg. Para obter detalhes completos desse processo, consulte a documentação oficial do Apple macOS.

1. Registre um único dispositivo ou registre vários dispositivos em sua conta de desenvolvedor da Apple.
2. No Xcode, vá para o Arquivo de Produto> para arquivar seu aplicativo.
3. Exporte o pacote usando o perfil de provisionamento adequado.

Windows

O App Center dá suporte à liberação de pacotes de aplicativos do Windows do tipo .appx, .appxbundle, .appxupload, .msi, .msix, .msixbundle, .msixupload ou .zip. Para obter detalhes completos sobre como empacotar seu aplicativo em formatos AppX ou MSIX, consulte a documentação oficial da UWP da Microsoft.

Sistema operacional personalizado

Arquive seu build para aplicativos com um sistema operacional personalizado no formato .zip.

Distribuindo o pacote

Para distribuir um pacote com o App Center, vá para o App Center, acesse seu aplicativo, vá para Distribuir>Grupos e selecione Nova versão. Siga as etapas no assistente.

Na primeira etapa, escolha a área Release para procurar o arquivo que você deseja carregar ou arraste e solte o arquivo na área. Dependendo do sistema operacional do seu aplicativo e da extensão de arquivo, o App Center pode solicitar que você insira uma versão e um número de build para sua versão. Insira as informações e escolha Avançar.

Você pode incluir notas de versão como parte de sua versão, tanto em texto sem formatação quanto no formato Markdown. Escolha Próximo.

Você pode direcionar sua versão para vários grupos de distribuição ou testadores. O App Center disponibiliza essa versão para os testadores e os usuários que fazem parte dos grupos selecionados. Escolha Próximo.

Ao lançar um aplicativo iOS, você pode provisionar automaticamente os dispositivos dos testadores. Escolha Próximo.

Reveja o lançamento. Se o aplicativo usar o SDK de Distribuição, você poderá configurar o App Center para tornar a versão obrigatória. Quando o App Center distribui uma versão, ele envia uma notificação por email da nova versão para todos os testadores definidos nos destinos. Você pode optar por não notificar os testadores na guia revisão. Por fim, escolha Distribuir para liberar o arquivo para seus testadores.

Distribuição usando a interface de linha de comando do App Center

Distribua sua versão usando o appcenter distribute release comando na CLI do App Center. O comando de exemplo a seguir distribui um arquivo chamado ~/releases/my_app-23.ipa para o grupo Beta testers do aplicativo My-App de propriedade David.

appcenter distribute release --app David/My-App --file ~/releases/my_app-23.ipa --group "Beta testers"

Distribuindo usando a API

Você pode chamar a API do App Center para distribuir uma versão. A abordagem a seguir destina-se a descrever uma abordagem de trabalho mínima, muitas das tarefas podem ser mais personalizadas ou automatizadas.

Uma implementação de exemplo pode ser vista aqui: https://github.com/microsoft/appcenter-Xamarin.UITest-Demo/blob/main/ac-distribute.sh

Pré-requisitos

• O pacote do aplicativo para upload e distribuição.
• Obter um token de API. Um Token de API é usado para autenticação para todas as chamadas à API do App Center.
• O Nome do Grupo de Distribuição (opcional, se ausente ou inválido, o upload ainda será concluído)
• Identifique {owner_name} e {app_name} para o aplicativo que você deseja distribuir uma versão. Esses identificadores são usados na URL para as chamadas à API. Para um aplicativo de propriedade de um usuário, a URL no App Center pode ter a seguinte aparência: https://appcenter.ms/users/Example-User/apps/Example-App. Aqui, o {owner_name} é Example-User e o {app_name} é Example-App. Para um aplicativo de propriedade de uma organização, a URL pode ser https://appcenter.ms/orgs/Example-Org/apps/Example-App e seria {owner_name}Example-Org.

Carregar nova versão

Carregue uma nova versão usando essas chamadas sequenciais de API:

1. Crie um novo upload de lançamento: chamar o endpoint POST /v0.1/apps/{owner_name}/{app_name}/uploads/releases

       OWNER_NAME="Example-Org"
       APP_NAME="Example-App"
       API_TOKEN="Example-Token"
   
       curl -X POST "https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/uploads/releases" -H  "accept: application/json" -H  "X-API-Token: $API_TOKEN" -H  "Content-Type: application/json" -H "Content-Length: 0"
   

   A resposta será semelhante a esta, com {VARIABLE_NAME} substituindo dados exclusivos para cada uso.

        {
            "id": "{ID}",
            "package_asset_id": "{PACKAGE_ASSET_ID}",
            "upload_domain": "https://file-aks.appcenter.ms",
            "token": "{TOKEN}",
            "url_encoded_token": "{URL_ENCODED_TOKEN}"
        }
   

2. Copie os parâmetros da resposta na etapa anterior, pois a maioria deles é usada na próxima etapa, incluindo o package_asset_id. upload_domainurl_encoded_token

   Determine o tamanho do pacote do aplicativo em bytes. É recomendável usar um comando como wc -c ExampleApp.ipa para obter uma contagem precisa de bytes.

   Defina o MIME Type para content_type com base no seu aplicativo.

   • O Android .apk usa o tipo de fornecedor application/vnd.android.package-archive
   • O Android .aab usa o tipo de fornecedor application/x-authorware-bin
   • O iOS usa o tipo geral application/octet-stream

   O comando final deve ser semelhante a este:

   FILE_NAME="ExampleApp.apk"
   FILE_SIZE_BYTES=$(wc -c $RELEASE_FILE_LOCATION | awk '{print $1}')
   APP_TYPE='application/vnd.android.package-archive' # iOS uses `application/octet-stream` instead.
   
   METADATA_URL="https://file-aks.appcenter.ms/upload/set_metadata/$PACKAGE_ASSET_ID?file_name=$FILE_NAME&file_size=$FILE_SIZE_BYTES&token=$URL_ENCODED_TOKEN&content_type=$APP_TYPE"
   
    curl -s -d POST -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" "$METADATA_URL"
   

   A saída retornada deve ser semelhante a esta:

    {
        "error":false,
        "id":"{PACKAGE_ASSET_ID}",
        "chunk_size":4194304,
        "resume_restart":false,
        "chunk_list":[1,2,3,4,5],
        "blob_partitions":1,
        "status_code":"Success"
    }
   

3. Usando o valor chunk_size que não pode ser personalizado, você pode dividir o upload do aplicativo em pequenos segmentos sequenciais para enviar para o Distribute. Por exemplo, você pode usar o split utilitário da seguinte maneira:

   split -b $CHUNK_SIZE $RELEASE_FILE_LOCATION temp/split
   

   Esse comando gera arquivos sequenciais no temp diretório denominado splitaa, splitabe assim por diante. Cada arquivo é dividido dentro do chunk_size limite.

4. Em seguida, você precisa carregar cada parte do pacote de aplicativo fracionado com o bloco correspondente.

   BLOCK_NUMBER=0
   
   for i in temp/*
   do
       BLOCK_NUMBER=$(($BLOCK_NUMBER + 1))
       CONTENT_LENGTH=$(wc -c "$i" | awk '{print $1}')
   
       UPLOAD_CHUNK_URL="https://file-aks.appcenter.ms/upload/upload_chunk/$PACKAGE_ASSET_ID?token=$URL_ENCODED_TOKEN&block_number=$BLOCK_NUMBER"
   
       curl -X POST $UPLOAD_CHUNK_URL --data-binary "@$i" -H "Content-Length: $CONTENT_LENGTH" -H "Content-Type: $CONTENT_TYPE"
   done
   

5. Depois que o upload for concluído, atualize o status do recurso de upload para uploadFinished.

   FINISHED_URL="https://file-aks.appcenter.ms/upload/finished/$PACKAGE_ASSET_ID?token=$URL_ENCODED_TOKEN"
   curl -d POST -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" "$FINISHED_URL"
   
   COMMIT_URL="https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/uploads/releases/$ID"
   curl -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" \
   --data '{"upload_status": "uploadFinished","id": "$ID"}' \
   -X PATCH \
   $COMMIT_URL
   

6. Depois de carregado, há um pequeno atraso antes que o upload seja marcado como concluído. Sondar este status para obter $RELEASE_ID para a próxima etapa:

   RELEASE_STATUS_URL="https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/uploads/releases/$UPLOAD_ID"
   POLL_RESULT=$(curl -s -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" $RELEASE_STATUS_URL)
   RELEASE_ID=$(echo $POLL_RESULT | jq -r '.release_distinct_id')
   
   if [[ $RELEASE_ID == null ]];
   then
      echo "Failed to find release from appcenter"
      exit 1
   fi
   

7. Por fim, libere o build. O ponto de extremidade a ser chamado é PATCH /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}

   DISTRIBUTE_URL="https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/releases/$RELEASE_ID"
   
   curl -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" \
   --data '{"destinations": [{ "name": "'"$DISTRIBUTION_GROUP"'"}] }' \    
   -X PATCH \
   $DISTRIBUTE_URL
   

Distribuir Versão

Distribua a versão carregada para testadores, grupos ou repositórios para ver a versão no portal do App Center. Os três pontos de extremidade são:

• POST /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}/testers
• POST /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}/groups
• POST /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}/stores

Um exemplo para grupos:

    curl -X POST -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" -d "{ \"id\": "$DISTRIBUTION_GROUP_ID", \"mandatory_update\": false, \"notify_testers\": false}" 

Você pode encontrar a ID do grupo de distribuição na página de configurações desse grupo.

A solicitação para distribuir para vários destinos é referenciada aqui para cenários mais complexos: PATCH /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}

Re-Release um build

Para liberar um build para outro grupo de distribuição, de qualquer lugar no App Center, vá para Distribuir > Versões e selecione a versão que você deseja distribuir novamente. A página de detalhes da liberação abre. Selecione o botão Distribuir no canto superior direito da tela e selecione o destino para iniciar o processo de relançamento. Siga as etapas no assistente e, por fim, selecione Distribuir para enviar a versão para grupos/testadores ou para o repositório.

Atualizações obrigatórias

Torne uma versão obrigatória para forçar todos os usuários a executar a mesma versão do seu aplicativo. Quando você fizer isso, o App Center instalará a atualização selecionada em todos os dispositivos testador.

Você só poderá tornar uma versão obrigatória se o aplicativo usar o SDK de Distribuição do App Center. Torne um lançamento obrigatório selecionando a caixa de seleção "Atualização obrigatória" no estágio de revisão da distribuição de um lançamento, ou utilize a API.

Você pode exibir versões obrigatórias no App Center abrindo [Seu Aplicativo] > Grupos de Distribuição > Lançamentos>. Os lançamentos obrigatórios são indicados por um ponto vermelho.

Link para lançamentos

Depois que você lançar com êxito, os testadores poderão acessar a versão por email, fazer login no App Center ou por meio de um link direto.

Você pode encontrar links para versões específicas na página de lançamento para destinos privados.

Você pode encontrar links para lançamentos específicos para destinos públicos na guia lançamentos em grupos públicos.