Rilasciare una build

Caricare il pacchetto binario dell'applicazione in App Center per distribuirlo. App Center supporta la distribuzione dei pacchetti per le app del sistema operativo Android, iOS, macOS, Windows e personalizzate. È possibile distribuire le versioni a singoli tester o gruppi di tester. Per le applicazioni iOS e Android, è anche possibile rilasciare nei negozi come Google Play, il App Store e Intune. Vedere Pubblicare negli archivi consumer e aziendali.

In questa pagina si apprenderà come generare il file binario per il rilascio e come caricarlo e rilasciarlo in gruppi usando il portale, l'interfaccia della riga di comando e l'API (Application Programming Interface).

È anche possibile usare Azure DevOps o Jenkins:

• Azure DevOps usa l'attività di distribuzione di App Center (versione 3+)
• Plug-in Jenkins (versione 0.11.0+).

Generazione di un pacchetto binario dell'applicazione

Prima di tutto, è necessario creare un pacchetto dell'applicazione in un file binario per il rilascio. È possibile creare questo file manualmente o usare App Center Build. È possibile configurare Build per la distribuzione automatica nella configurazione di compilazione di un ramo.

Le sezioni seguenti illustrano come creare i file per tutti i tipi di app supportati da App Center per la distribuzione.

Android

Per Android, è necessario produrre un bundle dell'app firmato o un file APK. Per informazioni dettagliate su questo processo, vedere la documentazione ufficiale di Google sulla preparazione di un'app per il rilascio.

1. Assicurarsi di aver aggiornato il manifesto e avere una compilazione Gradle configurata correttamente.
2. In Android Studio scegliere Genera>bundle/APK firmati e seguire i passaggi della procedura guidata per compilare il bundle dell'app o l'APK.

Android Studio inserisce bundle di app compilati inproject-name module-name//build/outputs/bundle/ e API in project-name/module-name/build/outputs/apk/.

iOS

Per iOS, è necessario produrre un pacchetto IPA per l'applicazione. Per informazioni dettagliate su questo processo, vedere la documentazione ufficiale di Apple.

1. Registrare UDID per tutti i dispositivi hardware nel profilo di provisioning.
2. In Xcode passare ad Archivio prodotti> per archiviare l'app.
3. Esportare l'archivio usando il profilo di provisioning appropriato.

macOS

Per macOS, devi produrre un pacchetto dell'app. App Center supporta il rilascio di pacchetti di app di tipo .app.zip, .pkg o .dmg. Per informazioni dettagliate su questo processo, vedere la documentazione ufficiale di Apple macOS.

1. Registrare un singolo dispositivo o registrare più dispositivi nell'account per sviluppatore Apple.
2. In Xcode passare ad Archivio prodotti> per archiviare l'app.
3. Esportare l'archivio usando il profilo di provisioning appropriato.

Windows

App Center supporta il rilascio di pacchetti di app Windows di tipo .appx, , .appxupload.appxbundle, .msi, .msix.msixbundle, .msixupload, o .zip. Per informazioni dettagliate su come creare un pacchetto dell'app nei formati AppX o MSIX, vedi la documentazione ufficiale di Microsoft UWP.

Sistema operativo personalizzato

Archiviare la compilazione per le app con un sistema operativo personalizzato in formato .zip.

Distribuzione del pacchetto

Per distribuire un pacchetto con App Center, passare ad App Center, passare all'app, quindi passare a Distribuisci>gruppi e selezionare Nuova versione. Seguire i passaggi nella procedura guidata.

Nel primo passaggio scegliere l'area Versione per cercare il file da caricare oppure trascinare il file nell'area. A seconda del sistema operativo dell'app e dell'estensione del file, App Center potrebbe chiedere di immettere una versione e un numero di build per la versione. Immettere le informazioni e scegliere Avanti.

È possibile includere le note sulla versione come parte della versione, sia in testo normale che in formato Markdown. Scegliere Avanti.

È possibile specificare come destinazione il rilascio a più gruppi di distribuzione o tester. App Center rende questa versione disponibile per i tester e gli utenti che fanno parte dei gruppi selezionati. Scegliere Avanti.

Quando si rilascia un'app iOS, è possibile effettuare automaticamente il provisioning dei dispositivi dei tester. Scegliere Avanti.

Esaminare la versione. Se l'app usa Distribute SDK, è possibile configurare App Center per rendere obbligatoria la versione. Quando App Center distribuisce una versione, invia una notifica tramite posta elettronica della nuova versione a tutti i tester impostati nelle destinazioni. È possibile scegliere di non inviare notifiche ai tester nella scheda revisione. Infine, scegliere Distribuisci per rilasciare il file ai tester.

Distribuzione tramite l'interfaccia della riga di comando di App Center

Distribuire il rilascio usando il appcenter distribute release comando nell'interfaccia della riga di comando di App Center. Il comando di esempio seguente distribuisce un file denominato ~/releases/my_app-23.ipa al gruppo Beta testers dell'app My-App di proprietà Daviddi .

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

Distribuzione tramite l'API

È possibile chiamare l'API di App Center per distribuire una versione. L'approccio seguente è destinato a descrivere un approccio di lavoro minimo, molte delle attività possono essere ulteriormente personalizzate o automatizzate.

Un'implementazione di esempio è disponibile qui: https://github.com/microsoft/appcenter-Xamarin.UITest-Demo/blob/main/ac-distribute.sh

Prerequisiti

• Pacchetto dell'app da caricare e distribuire.
• Ottenere un token API. Un token API viene usato per l'autenticazione per tutte le chiamate API di App Center.
• Nome del gruppo di distribuzione (facoltativo, se mancante o non valido, il caricamento continuerà a essere completato)
• Identificare e {owner_name}{app_name} per l'app per cui si vuole distribuire una versione. Questi identificatori vengono usati nell'URL per le chiamate API. Per un'app di proprietà di un utente, l'URL in App Center potrebbe essere simile a: https://appcenter.ms/users/Example-User/apps/Example-App. In questo caso, {owner_name} è Example-User e è Example-App{app_name} . Per un'app di proprietà di un'organizzazione, l'URL potrebbe essere https://appcenter.ms/orgs/Example-Org/apps/Example-App e sarebbe {owner_name}Example-Org.

Carica nuova versione

Caricare una nuova versione usando queste chiamate API sequenziali:

1. Creare un nuovo caricamento della versione: l'endpoint da chiamare è 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"
   

   La risposta avrà un aspetto simile al seguente, sostituendo {VARIABLE_NAME} i dati univoci per ogni uso:

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

2. Copiare i parametri dalla risposta nel passaggio precedente, perché la maggior parte di essi viene usata nel passaggio successivo, incluso package_asset_id, upload_domain & url_encoded_token.

   Determinare le dimensioni del pacchetto dell'app in byte. È consigliabile usare un comando, wc -c ExampleApp.ipa ad esempio per ottenere un conteggio accurato dei byte.

   Impostare per l'oggetto MIME Type in base all'app content_type :

   • Android .apk usa il tipo di fornitore application/vnd.android.package-archive
   • Android .aab usa il tipo di fornitore application/x-authorware-bin
   • iOS usa il tipo generale application/octet-stream

   Il comando finale dovrebbe essere simile al seguente:

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

   L'output restituito dovrebbe essere simile al seguente:

    {
        "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 il valore che non è possibile personalizzare, è possibile suddividere il caricamento dell'app chunk_size in blocchi sequenziali per il caricamento in Distribuisci. Ad esempio, è possibile usare l'utilità split , ad esempio:

   split -b $CHUNK_SIZE $RELEASE_FILE_LOCATION temp/split
   

   Questo comando genera file sequenziali nella temp directory denominata splitaa, splitabe così via. Ogni file viene suddiviso entro il chunk_size limite.

4. È quindi necessario caricare ogni blocco del pacchetto di app diviso con il rispettivo blocco:

   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.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. Al termine del caricamento, aggiornare lo stato della risorsa di caricamento in uploadFinished.

   FINISHED_URL="https://file.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. Una volta caricato, il caricamento ha un breve ritardo prima che il caricamento venga contrassegnato come completato. Eseguire il polling per questo stato per ottenere il $RELEASE_ID passaggio successivo:

   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. Infine, rilasciare la compilazione. L'endpoint da chiamare è PATCH /v0.1/apps/{owner_name}/{app_name}/release/{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
   

Distribuzione

Distribuire la versione caricata ai tester, ai gruppi o agli archivi per visualizzare la versione nel portale di App Center. I tre endpoint sono:

• POST /v0.1/apps/{owner_name}/{app_name}/release/{release_id}/testers
• POST /v0.1/apps/{owner_name}/{app_name}/release/{release_id}/groups
• POST /v0.1/apps/{owner_name}/{app_name}/release/{release_id}/store

Esempio per i gruppi:

    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}" 

È possibile trovare l'ID gruppo di distribuzione nella pagina delle impostazioni del gruppo.

La richiesta di distribuzione a più destinazioni viene fatto riferimento qui per scenari più complessi: PATCH /v0.1/apps/{owner_name}/{app_name}/release/{release_id}

Re-Release una compilazione

Per rilasciare una compilazione a un altro gruppo di distribuzione, da qualsiasi posizione in App Center passare a Distribuisci > versioni e quindi selezionare la versione da distribuire di nuovo. Verrà visualizzata la pagina dei dettagli della versione. Selezionare il pulsante Distribuisci nell'angolo in alto a destra della schermata e selezionare la destinazione per avviare il processo di ri-rilascio. Seguire la procedura descritta nella procedura guidata e infine selezionare Distribuisci per inviare la versione ai gruppi/tester o all'archivio.

Aggiornamenti obbligatori

Rendere obbligatoria una versione per forzare tutti gli utenti a eseguire la stessa versione dell'app. Quando si esegue questa operazione, App Center installerà l'aggiornamento selezionato in tutti i dispositivi tester.

È possibile rendere obbligatoria una versione solo se l'app usa App Center Distribute SDK. Impostare una versione obbligatoria selezionando la casella di controllo Aggiornamento obbligatorio nella fase di revisione della distribuzione di una versione oppure è possibile usare l'API.

È possibile visualizzare le versioni obbligatorie in App Center aprendo [App] > Distribuisci > gruppi>. Le versioni obbligatorie sono indicate da un punto rosso.

Collegamento alle versioni

Dopo aver rilasciato correttamente, i tester possono accedere alla versione tramite posta elettronica, accedere a App Center o tramite un collegamento diretto.

È possibile trovare collegamenti a versioni specifiche nella pagina di rilascio per le destinazioni private.

È possibile trovare collegamenti a versioni specifiche alle destinazioni pubbliche nella scheda versioni nei gruppi pubblici.