Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
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:
- Azure DevOps usa l'attività 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.
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.
- Assicurarsi di aver aggiornato il manifesto e di avere una build Gradle configurata correttamente.
- 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.
- Registrare gli UDID per tutti i dispositivi hardware nel profilo di provisioning.
- In Xcode passare a Archivio prodotti> per archiviare l'app.
- 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.
- Registrare un singolo dispositivo o registrare più dispositivi nell'account per sviluppatore Apple.
- In Xcode passare a Archivio prodotti> per archiviare l'app.
- 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
, .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
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.
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.
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:
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 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 ilcontent_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" }
-
Android .apk usa il tipo di fornitore
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 denominatasplitaa
,splitab
e così via. Ogni file viene suddiviso entro ilchunk_size
limite.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
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
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
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:
- 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
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.
Collegamento ai rilasci
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.
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.