Einen Build freigeben

Laden Sie Ihr Anwendungs-Binärpaket in App Center hoch, um es zu verteilen. App Center unterstützt die Paketverteilung für Android-, iOS-, macOS-, Windows- und benutzerdefinierte Betriebssystem-Apps. Sie können Versionen an einzelne Tester oder Gruppen von Testern verteilen. Für iOS- und Android-Anwendungen können Sie auch in den Stores wie Google Play, app Store und Intune veröffentlichen. Weitere Informationen finden Sie unter Veröffentlichen in App- und Unternehmens-Stores.

Auf dieser Seite erfahren Sie, wie Sie die Binärdatei für die Veröffentlichung generieren und sie mithilfe des Portals, der Befehlszeilenschnittstelle (CLI) und der Anwendungsprogrammierschnittstelle (API) in Gruppen hochladen und freigeben.

Sie können auch Azure DevOps oder Jenkins verwenden:

• Azure DevOps verwendet die App Center-Verteilungsaufgabe (Version 3+)
• Jenkins Plugin (Version 0.11.0+)

Generieren eines Anwendungs-Binärpakets

Zuerst müssen Sie Ihre Anwendung in eine Binärdatei packen, um sie freizugeben. Sie können diese Datei manuell erstellen.

In den folgenden Abschnitten wird erläutert, wie die Dateien für alle von App Center unterstützten App-Typen zur Verteilung erstellt werden.

Android

Für Android müssen Sie ein signiertes App-Bündel oder eine APK-Datei erstellen. Ausführliche Informationen zu diesem Prozess finden Sie in der offiziellen Google-Dokumentation zur Vorbereitung einer App für die Veröffentlichung.

1. Stellen Sie sicher, dass Sie das Manifest aktualisiert haben und einen ordnungsgemäß konfigurierten Gradle-Build haben.
2. Wählen Sie in Android Studio die Option Build>Generate Signed Bundle / APK aus, und führen Sie die Schritte im Assistenten aus, um das App-Bündel oder APK zu erstellen.

Android Studio platziert integrierte App-Bündel im Projektnamen/modul-name/build/outputs/bundle/ und APKs in project-name/module-name/build/outputs/apk/.

Ios

Für iOS müssen Sie ein IPA-Paket für Ihre Anwendung erstellen. Ausführliche Informationen zu diesem Prozess finden Sie in der offiziellen Apple-Dokumentation.

1. Registrieren Sie UDIDs für alle Hardwaregeräte in Ihrem Bereitstellungsprofil.
2. Wechseln Sie in Xcode zum Produktarchiv>, um Ihre App zu archivieren.
3. Exportieren Sie das Archiv mithilfe des richtigen Bereitstellungsprofils.

macOS

Für macOS müssen Sie ein App-Paket erstellen. App Center unterstützt das Freigeben von App-Paketen vom Typ .app.zip, .pkg oder .dmg. Ausführliche Informationen zu diesem Prozess finden Sie in der offiziellen Apple macOS-Dokumentation.

1. Registrieren Sie ein einzelnes Gerät , oder registrieren Sie mehrere Geräte in Ihrem Apple-Entwicklerkonto.
2. Wechseln Sie in Xcode zum Produktarchiv>, um Ihre App zu archivieren.
3. Exportieren Sie das Archiv mithilfe des richtigen Bereitstellungsprofils.

Fenster

App Center unterstützt das Freigeben von Windows-App-Paketen vom Typ .appx, , , .appxbundle, .appxupload, .msi.msix, oder .msixbundle.msixupload. .zip Ausführliche Informationen zum Verpacken Ihrer App in AppX- oder MSIX-Formaten finden Sie in der offiziellen Microsoft UWP-Dokumentation.

Benutzerdefiniertes Betriebssystem

Archivieren Sie Ihren Build für Apps mit einem benutzerdefinierten Betriebssystem im .zip Format.

Verteilen des Pakets

Um ein Paket mit App Center zu verteilen, wechseln Sie zum App Center, wechseln Sie zu Ihrer App, und wechseln Sie dann zu"Gruppen>", und wählen Sie "Neue Version" aus. Folgen Sie den Anweisungen des Assistenten.

Wählen Sie im ersten Schritt den Bereich "Release" aus, um nach der Datei zu suchen, die Sie hochladen möchten, oder ziehen Sie die Datei in den Bereich. Je nach Betriebssystem Ihrer App und der Dateierweiterung werden Sie möglicherweise von App Center aufgefordert, eine Version und Buildnummer für Ihre Version einzugeben. Geben Sie die Informationen ein, und wählen Sie "Weiter" aus.

Sie können Versionshinweise als Teil Ihrer Version sowohl im Nur-Text- als auch im Markdown-Format einschließen. Wählen Sie Weiteraus.

Sie können Ihre Veröffentlichung auf mehrere Verteilergruppen oder Tester ausrichten. App Center stellt diese Version diesen Testern und den Benutzern, die Teil der ausgewählten Gruppen sind, zur Verfügung. Wählen Sie Weiteraus.

Beim Freigeben einer iOS-App können Sie die Geräte Ihrer Tester automatisch bereitstellen. Wählen Sie Weiteraus.

Überprüfen Sie die Freigabe. Wenn Ihre App das Distribute SDK verwendet, können Sie App Center so konfigurieren, dass die Veröffentlichung obligatorisch ist. Wenn App Center eine Version verteilt, sendet es eine E-Mail-Benachrichtigung der neuen Version an alle Tester, die in den Zielen festgelegt sind. Sie können die Tester auf der Registerkarte "Überprüfen" nicht benachrichtigen. Wählen Sie schließlich "Verteilen" aus, um die Datei für Ihre Tester freizugeben.

Verteilen mithilfe der Befehlszeilenschnittstelle von App Center

Verteilen Sie Ihre Freigabe über den appcenter distribute release Befehl in der App Center CLI. Der folgende Beispielbefehl verteilt eine Datei namens ~/releases/my_app-23.ipa an die Gruppe Beta testers der App My-App, die im Besitz von David ist.

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

Verteilen mithilfe der API

Sie können die App Center-API aufrufen, um eine Version zu verteilen. Der folgende Ansatz soll einen minimalen Arbeitsansatz beschreiben, viele der Aufgaben können weiter angepasst oder automatisiert werden.

Hier finden Sie eine Beispielimplementierung: https://github.com/microsoft/appcenter-Xamarin.UITest-Demo/blob/main/ac-distribute.sh

Voraussetzungen

• Das App-Paket, das hochgeladen und verteilt werden soll.
• Abrufen eines API-Tokens. Ein API-Token wird für die Authentifizierung für alle App Center-API-Aufrufe verwendet.
• Der Name der Verteilergruppe (optional, wenn fehlend oder ungültig, wird der Upload dennoch abgeschlossen)
• Identifizieren Sie die {owner_name} und {app_name} für die App, für die Sie eine Freigabe verteilen möchten. Diese Bezeichner werden in der URL für die API-Aufrufe verwendet. Für eine App, die einem Benutzer gehört, kann die URL im App Center wie folgt aussehen: https://appcenter.ms/users/Example-User/apps/Example-App Hier ist {owner_name} und Example-User und das {app_name} ist Example-App. Für eine App, die einer Organisation gehört, könnte die URL https://appcenter.ms/orgs/Example-Org/apps/Example-App sein und {owner_name} wäre Example-Org.

Neue Version hochladen

Laden Sie eine neue Version mit diesen sequenziellen API-Aufrufen hoch:

1. Erstellen eines neuen Releaseuploads: Der endpunkt zum Aufrufen ist 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"
   

   Die Antwort sieht ungefähr so aus, wobei {VARIABLE_NAME} Daten ersetzt, die je nach Verwendung unterschiedlich sind.

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

2. Kopieren Sie die Parameter aus der Antwort im vorherigen Schritt, da die meisten von ihnen im nächsten Schritt verwendet werden, einschließlich der package_asset_id, upload_domain & url_encoded_token.

   Bestimmen Sie die Größe Ihres App-Pakets in Byte. Es wird empfohlen, einen Befehl wie wc -c ExampleApp.ipa zu verwenden, um eine genaue Byteanzahl zu erhalten.

   Legen Sie den MIME Type basierend auf Ihrer App für die content_type fest.

   • Android .apk verwendet den Anbietertyp application/vnd.android.package-archive
   • Android .aab verwendet den Anbietertyp application/x-authorware-bin
   • iOS verwendet den allgemeinen Typ application/octet-stream

   Der letzte Befehl sollte etwa wie folgt aussehen:

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

   Die zurückgegebene Ausgabe sollte etwa wie folgt aussehen:

    {
        "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. Mithilfe des chunk_size-Werts, der nicht angepasst werden kann, können Sie den App-Upload in sequenzielle Abschnitte unterteilen, um ihn auf Distribute hochzuladen. Sie können z. B. das split Hilfsprogramm wie folgt verwenden:

   split -b $CHUNK_SIZE $RELEASE_FILE_LOCATION temp/split
   

   Mit diesem Befehl werden sequenzielle Dateien im temp Verzeichnis namens splitaa, splitabusw. generiert. Jede Datei wird innerhalb des chunk_size Grenzwerts geteilt.

4. Als Nächstes müssen Sie jeden Teil des geteilten App-Pakets mit dem entsprechenden Block hochladen:

   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-aks.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. Aktualisieren Sie nach Abschluss des Uploads den Status der Uploadressource auf uploadFinished.

   FINISHED_URL="https://file-aks.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. Nach dem Hochladen gibt es eine kurze Verzögerung, bevor der Upload als abgeschlossen markiert ist. Fragen Sie diesen Status ab, um das $RELEASE_ID für den nächsten Schritt zu erhalten.

   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. Veröffentlichen Sie schließlich den Build. Der endpunkt, der aufgerufen werden soll, ist 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
   

Freigabe verteilen

Verteilen Sie die hochgeladene Version an Tester, Gruppen oder Stores, um die Version im App Center-Portal anzuzeigen. Die drei Endpunkte sind:

• 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

Beispiel für Gruppen:

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

Die Verteilergruppen-ID finden Sie auf der Einstellungsseite dieser Gruppe.

Auf die Anforderung zum Verteilen an mehrere Ziele wird hier für komplexere Szenarien verwiesen: PATCH /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}

Re-Release ein Build

Um einen Build an einer anderen Verteilergruppe freizugeben, wechseln Sie von jedem Ort im App Center zu "Releases verteilen>", und wählen Sie dann die Version aus, die Sie erneut verteilen möchten. Die Versionsdetailseite wird geöffnet. Wählen Sie in der oberen rechten Ecke des Bildschirms die Schaltfläche " Verteilen " aus, und wählen Sie das Ziel aus, um den Prozess der erneuten Freigabe zu starten. Führen Sie die Schritte im Assistenten aus, und wählen Sie schließlich "Verteilen" aus, um die Version an Gruppen/Tester oder den Store zu senden.

Obligatorische Updates

Machen Sie eine Veröffentlichung obligatorisch, um zu erzwingen, dass alle Benutzer dieselbe Version Ihrer App ausführen. In diesem Fall installiert App Center das ausgewählte Update auf allen Testergeräten.

Sie können eine Veröffentlichung nur obligatorisch machen, wenn Ihre App das App Center Distribute SDK verwendet. Machen Sie eine Veröffentlichung obligatorisch, indem Sie das Kontrollkästchen "Obligatorisches Update " in der Überprüfungsphase der Verteilung einer Version aktivieren oder die API verwenden.

Sie können obligatorische Freigaben im App Center anzeigen, indem Sie [Ihre App] > Verteilen > Gruppen > Freigaben öffnen. Obligatorische Veröffentlichungen werden durch einen roten Punkt angezeigt.

Link zu Veröffentlichungen

Nachdem Sie erfolgreich veröffentlicht haben, können Ihre Tester per E-Mail auf die Version zugreifen, sich beim App Center anmelden oder über einen direkten Link.

Links zu bestimmten Veröffentlichungen finden Sie auf der Veröffentlichungsseite für private Destinationen.

Links zu bestimmten Veröffentlichungen zu öffentlichen Zielen finden Sie auf der Registerkarte "Veröffentlichungen" in öffentlichen Gruppen.