Rilasciare una build
Importante
Visual Studio App Center è pianificato per il ritiro il 31 marzo 2025. Anche se è possibile continuare a usare Visual Studio App Center fino a quando non viene completamente ritirato, esistono diverse alternative consigliate a cui è possibile prendere in considerazione la migrazione.
Altre informazioni sulle sequenze temporali di supporto e sulle alternative.
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+).
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.
Nota
Se si intende caricare l'archivio (.zip, .ipa e altri), le dimensioni totali dell'app non compresse devono essere inferiori a 4 GB.
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.
- Assicurarsi di aver aggiornato il manifesto e avere una compilazione Gradle configurata correttamente.
- 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/.
Nota
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.
Per iOS, è necessario produrre un pacchetto IPA per l'applicazione. Per informazioni dettagliate su questo processo, vedere la documentazione ufficiale di Apple.
- Registrare UDID per tutti i dispositivi hardware nel profilo di provisioning.
- In Xcode passare ad Archivio prodotti> per archiviare l'app.
- Esportare l'archivio usando il profilo di provisioning appropriato.
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.
- Registrare un singolo dispositivo o registrare più dispositivi nell'account per sviluppatore Apple.
- In Xcode passare ad Archivio prodotti> per archiviare l'app.
- Esportare l'archivio usando il profilo di provisioning appropriato.
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.
Archiviare la compilazione per le app con un sistema operativo personalizzato in formato .zip.
Nota
Tutti gli URL install.appcenter.ms contenenti 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 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.
Avviso
Per usare questa funzionalità, è necessaria l'interfaccia della riga di comando di App Center 2.7 o versione successiva.
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à David
di .
appcenter distribute release --app David/My-App --file ~/releases/my_app-23.ipa --group "Beta testers"
È 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
- 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
.
Caricare una nuova versione usando queste chiamate API sequenziali:
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}" }
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'appcontent_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" }
- Android .apk usa il tipo di fornitore
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 denominatasplitaa
,splitab
e così via. Ogni file viene suddiviso entro ilchunk_size
limite.È 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
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
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
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
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}
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.
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.
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.
Nota
I bundle di applicazioni Android (AAB) sono disponibili per il download nella pagina della versione facendo clic sul pulsante 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 a matrice generato accanto al pulsante di download.
È possibile trovare collegamenti a versioni specifiche alle destinazioni pubbliche nella scheda versioni nei gruppi pubblici.