Partager via

Publier une build

Important

Visual Studio App Center a été mis hors service le 31 mars 2025, à l’exception des fonctionnalités d’analyse et de diagnostic, qui continueront d’être prises en charge jusqu’au 30 juin 2026. En savoir plus.

Chargez votre package binaire d’application dans App Center pour le distribuer. App Center prend en charge la distribution de packages pour les applications de système d’exploitation android, iOS, macOS, Windows et personnalisées. Vous pouvez distribuer des versions à des testeurs individuels ou à des groupes de testeurs. Pour les applications iOS et Android, vous pouvez également publier sur les magasins tels que Google Play, l’App Store et Intune. Voir Publier dans les magasins grand public et d’entreprise.

Dans cette page, vous pouvez apprendre à générer le fichier binaire pour la mise en production et à le charger et à le libérer sur des groupes à l’aide du portail, de l’interface de ligne de commande (CLI) et de l’interface de programmation d’application (API).

Vous pouvez également utiliser Azure DevOps ou Jenkins :

Génération d’un package binaire d’application

Tout d’abord, vous devez empaqueter votre application dans un fichier binaire pour la mise en production. Vous pouvez créer ce fichier manuellement.

Les sections suivantes expliquent comment créer les fichiers pour tous les types d’applications pris en charge par App Center pour la distribution.

Remarque

Si vous allez charger l’archive (.zip, .ipa et d’autres), la taille totale non compressée de votre application doit être inférieure à 4 Go.

Android

Pour Android, vous devez produire un ensemble d’applications signé ou un fichier APK. Pour plus d’informations sur ce processus, consultez la documentation google officielle sur la préparation d’une application pour la publication.

  1. Vérifiez que vous avez mis à jour le manifeste et que vous disposez d’une build Gradle correctement configurée.
  2. Dans Android Studio, choisissez Build>Générer un bundle signé / APK et suivez les étapes de l’assistant pour générer le bundle d’application ou APK.

Android Studio place des bundles d’applications intégrés dans project-name/module-name/build/outputs/bundle/ et APKs dans project-name/module-name/build/outputs/apk/.

Remarque

Lorsque vous distribuez Android Application Bundle (AAB), App Center génère un APK universel, le signe avec une clé de signature générée et le distribue à un appareil.

Ios

Pour iOS, vous devez produire un package IPA pour votre application. Pour plus d’informations sur ce processus, consultez la documentation officielle d’Apple.

  1. Inscrivez des UDID pour tous les appareils matériels dans votre profil d’approvisionnement.
  2. Dans Xcode, accédez à Product>Archive pour archiver votre application.
  3. Exportez l’archive à l’aide du profil d’approvisionnement approprié.

macOS

Pour macOS, vous devez produire un package d’application. App Center prend en charge la publication de packages d’application de type .app.zip, .pkg ou .dmg. Pour plus d’informations sur ce processus, consultez la documentation officielle d’Apple macOS.

  1. Inscrivez un seul appareil ou inscrivez plusieurs appareils dans votre compte de développeur Apple.
  2. Dans Xcode, accédez à Product>Archive pour archiver votre application.
  3. Exportez l’archive à l’aide du profil d’approvisionnement approprié.

Fenêtres

App Center prend en charge la publication des packages d'application Windows de type .appx, .appxbundle, .appxupload, .msi, .msix, .msixbundle, .msixupload, ou .zip. Pour plus d’informations sur la façon de empaqueter votre application dans des formats AppX ou MSIX, consultez la documentation officielle de Microsoft UWP.

Système d’exploitation personnalisé

Archivez votre build pour les applications avec un système d’exploitation personnalisé au format .zip.

Distribution du package

Remarque

Toutes les URL install.appcenter.ms qui contiennent des fichiers à télécharger sont accessibles publiquement.

Pour distribuer un package avec App Center, accédez à App Center, accédez à votre application, puis accédez à Distribuer des>groupes et sélectionnez Nouvelle version. Suivez les étapes de l'Assistant. Distribution d’une nouvelle version

Dans la première étape, choisissez la zone De mise en production pour rechercher le fichier que vous souhaitez charger, ou faites glisser-déplacer le fichier dans la zone. Selon le système d’exploitation de votre application et l’extension de fichier, App Center peut vous demander d’entrer une version et un numéro de build pour votre version. Entrez les informations et choisissez Suivant.

Vous pouvez inclure des notes de publication dans le cadre de votre version, au format texte brut ou Markdown. Choisissez Suivant.

Vous pouvez cibler votre version sur plusieurs groupes de distribution ou testeurs. App Center met cette version à la disposition de ces testeurs et des utilisateurs qui font partie des groupes sélectionnés. Choisissez Suivant.

Définition des destinations de mise en production

Lors de la publication d’une application iOS, vous pouvez provisionner automatiquement les appareils de vos testeurs. Choisissez Suivant.

Passez en revue la version. Si votre application utilise le Kit de développement logiciel (SDK) Distribuer, vous pouvez configurer App Center pour rendre la version obligatoire. Lorsque App Center distribue une version, il envoie une notification par e-mail de la nouvelle version à tous les testeurs définis dans les destinations. Vous pouvez choisir de ne pas notifier les testeurs dans l’onglet Révision. Enfin, choisissez Distribuer pour libérer le fichier sur vos testeurs.

Distribution à l’aide de l’interface de ligne de commande App Center

Avertissement

Vous avez besoin d’App Center CLI 2.7 ou version ultérieure pour utiliser cette fonctionnalité.

Distribuez votre version à l’aide de la appcenter distribute release commande dans l’interface CLI App Center. L’exemple de commande suivant distribue un fichier appelé ~/releases/my_app-23.ipa au groupe Beta testers de l’application My-App appartenant à David.

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

Distribution à l’aide de l’API

Vous pouvez appeler l’API App Center pour distribuer une version. L’approche ci-dessous est destinée à décrire une approche de travail minimale, la plupart des tâches peuvent être personnalisées ou automatisées.

Vous trouverez ici un exemple d’implémentation : https://github.com/microsoft/appcenter-Xamarin.UITest-Demo/blob/main/ac-distribute.sh

Conditions préalables

  • Package d’application à charger et distribuer.
  • Obtenez un jeton d’API. Un jeton d’API est utilisé pour l’authentification pour tous les appels d’API App Center.
  • Nom du groupe de distribution (facultatif, s’il manque ou n’est pas valide, le chargement est toujours terminé)
  • Identifiez les éléments {owner_name} et {app_name} de l'application pour laquelle vous souhaitez distribuer une version. Ces identificateurs sont utilisés dans l’URL des appels d’API. Pour une application appartenant à un utilisateur, l’URL dans App Center peut ressembler à : https://appcenter.ms/users/Example-User/apps/Example-App. Ici, le {owner_name} est Example-User et le {app_name} est Example-App. Pour une application appartenant à une organisation, l’URL peut être https://appcenter.ms/orgs/Example-Org/apps/Example-App et l’url {owner_name} serait Example-Org.
Charger une nouvelle version

Chargez une nouvelle version à l’aide de ces appels d’API séquentiels :

  1. Créer un nouveau téléversement de version : le point de terminaison à appeler est 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 réponse ressemblera à ceci, en {VARIABLE_NAME} remplaçant les données uniques à chaque utilisation :

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

  2. Copiez les paramètres de la réponse à l’étape précédente, car la plupart d’entre eux sont utilisés à l’étape suivante, y compris le package_asset_id, upload_domain et url_encoded_token.

    Déterminez la taille de votre package d’application en octets. Il est recommandé d’utiliser une commande telle que wc -c ExampleApp.ipa pour obtenir un nombre d’octets précis.

    Définissez le MIME Type pour le content_type en fonction de votre application :

    • Android .apk utilise le type de fournisseur application/vnd.android.package-archive
    • Android .aab utilise le type de fournisseur application/x-authorware-bin
    • iOS utilise le type général application/octet-stream

    La commande finale doit ressembler à ceci :

    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"

    La sortie retournée doit ressembler à ceci :

     {
     "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. À l’aide de la chunk_size valeur qui ne peut pas être personnalisée, vous pouvez fractionner le chargement de votre application en blocs séquentiels pour le chargement sur Distribuer. Par exemple, vous pouvez utiliser l’utilitaire split comme suit :

    split -b $CHUNK_SIZE $RELEASE_FILE_LOCATION temp/split

    Cette commande génère des fichiers séquentiels dans le temp répertoire nommé splitaa, splitabet ainsi de suite. Chaque fichier est divisé sous la limite de chunk_size.

  4. Ensuite, vous devez charger chaque bloc du package d’application fractionné avec le bloc respectif :

    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. Une fois le chargement terminé, mettez à jour l’état de la ressource de chargement sur 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. Une fois chargé, il existe un court délai avant que le chargement soit marqué comme terminé. Interrogez cet état pour obtenir le $RELEASE_ID nécessaire à l'étape suivante :

    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. Enfin, publiez la version. Le point de terminaison à appeler est 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
Distribuer la version

Distribuez la version téléchargée aux testeurs, groupes ou magasins pour voir la version dans l'interface du App Center. Les trois points de terminaison sont les suivants :

Exemple pour les groupes :

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

Vous trouverez l’ID du groupe de distribution dans la page des paramètres de ce groupe.

La demande de distribution vers plusieurs destinations est référencée ici pour des scénarios plus complexes : PATCH /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}

Re-Release une version

Pour libérer une build vers un autre groupe de distribution, à partir de n’importe quel emplacement dans App Center, accédez à Distribuer > les versions , puis sélectionnez la version que vous souhaitez distribuer à nouveau. La page des détails de publication s’ouvre. Sélectionnez le bouton Distribuer dans le coin supérieur droit de l’écran et sélectionnez la destination pour démarrer le processus de reversion. Suivez les étapes de l’Assistant, puis sélectionnez Distribuer pour envoyer la version aux groupes/testeurs ou au magasin.

Mises à jour obligatoires

Rendez une version obligatoire pour forcer tous les utilisateurs à exécuter la même version de votre application. Lorsque vous procédez ainsi, App Center installe la mise à jour sélectionnée sur tous les appareils testeurs.

Vous ne pouvez rendre une version obligatoire que si votre application utilise le SDK App Center Distribute. Rendez une mise à jour obligatoire en sélectionnant la case Mise à jour obligatoire à l'étape de révision de la distribution d'une version, ou utilisez l'API.

Vous pouvez afficher les versions obligatoires dans App Center en ouvrant [Votre application] > Distribuer > des versions de groupes>. Les publications obligatoires sont indiquées par un point rouge.

Une fois que vous avez publié avec succès, vos testeurs peuvent accéder à la version par e-mail, se connecter à App Center ou via un lien direct.

Vous trouverez des liens vers des versions spécifiques sur la page de publication pour les destinations privées. Bouton Installer

Remarque

Les bundles d’applications Android (AAB) sont disponibles en téléchargement sur la page de publication en cliquant sur le bouton télécharger. Si vous avez besoin d’un format de fichier APK installable, utilisez le portail d’installation (https://install.appcenter.ms) sur votre appareil. Vous trouverez le lien sous le code QR généré en regard du bouton de téléchargement.

Vous trouverez des liens vers des versions spécifiques vers des destinations publiques sous l’onglet Versions dans les groupes publics. Lien profond public