Condividi tramite

Rilasciare una build

Importante

Visual Studio App Center è stato ritirato il 31 marzo 2025, ad eccezione delle funzionalità di Analisi e diagnostica, che continueranno a essere supportate fino al 30 giugno 2026. Ulteriori informazioni.

Caricare il pacchetto binario dell'applicazione in App Center per distribuirlo. App Center supporta la distribuzione dei pacchetti per le app android, iOS, macOS, Windows e del sistema operativo personalizzato. È 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, App Store e Intune. Vedere Pubblicare nei negozi 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:

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.

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

Annotazioni

Se vuoi caricare l'archivio (.zip, ipa e altri), le dimensioni totali dell'app non compresse devono essere inferiori a 4 GB.

Androide

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 di avere una build Gradle configurata correttamente.
  2. In Android Studio scegliere Genera>bundle/APK firmato e seguire i passaggi della procedura guidata per compilare il bundle dell'app o l'APK.

Android Studio posiziona i pacchetti di app costruiti in project-name/module-name/build/outputs/bundle/ e gli APK in project-name/module-name/build/outputs/apk/.

Annotazioni

Quando si distribuisce Il bundle di applicazioni Android (AAB), App Center genera un APK universale, lo firma con una chiave di firma generata e lo distribuisce a un dispositivo.

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 gli UDID per tutti i dispositivi hardware nel profilo di provisioning.
  2. In Xcode passare a Archivio prodotti> per archiviare l'app.
  3. Esporta l'archivio utilizzando il profilo di provisioning corretto.

macOS

Per macOS, è necessario 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 a Archivio prodotti> per archiviare l'app.
  3. Esporta l'archivio utilizzando il profilo di provisioning corretto.

Windows

App Center supporta il rilascio di pacchetti di app di Windows di tipo .appx, .appxbundle.appxupload.msi.msix.msixbundle, .msixuploado ..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

Archivia la build per le app con un sistema operativo personalizzato in formato .zip.

Distribuzione del pacchetto

Annotazioni

Tutti gli URL install.appcenter.ms che contengono file per il download sono accessibili pubblicamente.

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 della procedura guidata. Distribuzione di una nuova versione

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

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

È possibile impostare come destinazione il rilascio in 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.

Impostazione delle destinazioni di rilascio

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

Esaminare il rilascio. 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

Avvertimento

Per usare questa funzionalità, è necessaria l'interfaccia della riga di comando di App Center 2.7 o versione successiva.

Distribuisci la tua release usando il appcenter distribute release comando nell'App Center CLI. Il comando di esempio seguente distribuisce un file denominato ~/releases/my_app-23.ipa al gruppo Beta testers dell'app My-App di proprietà di David.

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 è progettato per 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 {owner_name} e {app_name} per l'app per cui si desidera 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 al seguente: https://appcenter.ms/users/Example-User/apps/Example-App. Qui, {owner_name} è Example-User e {app_name} è Example-App. 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.
Caricare una 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 la dimensione del pacchetto dell'app in byte. È consigliabile usare un comando, wc -c ExampleApp.ipa ad esempio per ottenere un conteggio dei byte accurato.

    Imposta il MIME Type per il content_type basato sulla tua app.

    • Android .apk usa il tipo di fornitore application/vnd.android.package-archive
    • Android .aab usa il tipo 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 chunk_size che non può essere personalizzato, puoi suddividere il caricamento dell'app in blocchi sequenziali per caricarla su Distribute. Ad esempio, è possibile usare l'utilità split come segue:

    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. Successivamente, è necessario caricare ciascuno spezzone del pacchetto dell'app divisa nel 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. Dopo il caricamento, si verifica un breve ritardo prima che il caricamento venga contrassegnato come completato. Eseguire il polling di questo stato per ottenere il $RELEASE_ID per il 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 build. L'endpoint da chiamare è 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
Distribuisci versione

Distribuire la release caricata a tester, gruppi o store per visualizzarla nel portale di App Center. I tre endpoint sono:

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 del gruppo di distribuzione nella pagina delle impostazioni del gruppo.

Per scenari più complessi viene fatto riferimento alla richiesta di distribuzione a più destinazioni: PATCH /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}

Re-Release una compilazione

Per rilasciare una build in un altro gruppo di distribuzione, da qualsiasi posizione in App Center passare a Distribuisci > versioni e quindi selezionare la versione che si vuole distribuire di nuovo. Si apre la pagina dei dettagli della release. Selezionare il pulsante Distribuisci nell'angolo superiore destro della schermata e selezionare la destinazione per avviare il processo di ri-rilascio. Seguire i passaggi della procedura guidata e infine selezionare Distribuisci per inviare la versione a gruppi/tester o all'archivio.

Aggiornamenti obbligatori

Rendi obbligatorio un rilascio per forzare l'esecuzione della stessa versione dell'app da parte di tutti gli utenti. 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. Rendere obbligatoria una versione 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 [Your App] > Distribute > Groups Releases (Distribuisci versioni dei gruppi>). Le versioni obbligatorie sono indicate da un punto rosso.

Una volta rilasciato correttamente, i tester possono accedere alla versione tramite posta elettronica, accedere ad App Center o tramite un collegamento diretto.

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

Annotazioni

I bundle di applicazioni Android (AAB) sono disponibili per il download nella pagina di rilascio facendo clic sul pulsante di download. Se è necessario un formato di file APK installabile, usare il portale di installazione (https://install.appcenter.ms) nel dispositivo. È possibile trovare il collegamento sotto il codice QR generato accanto al pulsante di download.

È possibile trovare collegamenti a versioni specifiche a destinazioni pubbliche nella scheda Versioni nei gruppi pubblici. Collegamento diretto pubblico