Automatische iOS-Builds mit GitHub Actions via Match
Das Einrichten von CI/CD für Capacitor-Apps kann komplex und zeitaufwendig sein. Hier ist das Wichtigste:
Empfohlen für neue Builds: Nutze Capgo Build
Wir empfehlen jetzt Capgo Build mit Capgo CLI für native Capacitor Builds. Dieser Fastlane-Match-Guide wird für Teams beibehalten, die bestehende GitHub-Actions-Pipelines pflegen. Neue iOS-Builds sollten jedoch Capgo CLI verwenden, damit Sie Fastlane, Match-Repositories, Xcode-Runner, Zertifikate und Upload-Skripte nicht selbst pflegen müssen.
Capgo Build für CI/CD von Capgo
Sparen Sie sich die Pflege von Fastlane Match, Xcode-Runnern, Zertifikaten, Provisioning-Profilen und Upload-Skripten. Capgo Build führt signierte native iOS-Builds aus Ihrer bestehenden CI/CD-Pipeline aus:
- Funktioniert mit Ihrer Pipeline: Starten Sie Capgo Build aus GitHub Actions, GitLab CI, Jenkins oder lokalen Skripten nach Ihrem Web-Build und
npx cap sync. - Signing aus CI-Secrets: Bewahren Sie App Store Connect-Keys, Zertifikate, Provisioning-Profile, Passwörter und Team-IDs in Ihren eigenen CI-Secrets auf.
- Kein Wartungsaufwand für native RunnerCapgo Build bietet gewartete Apple-Buildumgebungen, sodass du dich nicht um macOS-Runner, Xcode-Images, Fastlane oder Match-Repositories kümmern musst.
- Artefakte und Einreichung: Lade signierte Artefakte für QA herunter oder reiche Release-Builds über Capgo CLI ein.
Preise
- Capgo-Pläne ab 12 $/Monat
- Inklusive OTA-Updates und ca. 15 Native Builds pro Monat
- Zusätzliche Build-Minuten werden minutengenau über Credits abgerechnet
Capgo Build in CI/CD einrichten
Manuelle Setup-Anleitung
Das müssen Sie tun:
Continuous Delivery für iOS mit Fastlane und GitHub Actions mit match
Voraussetzungen
Bevor wir mit dem Tutorial fortfahren…
- Stellen Sie sicher, dass Sie Fastlane installiert auf Ihrer Entwicklungsmaschine haben.
- Mitgliedschaft im iOS Developer Program.
- Lust zu lesen? 😆…
- Ein Team mit vielen Devs, sonst empfehlen wir fastlane cert für einfachere Workflows.
Wichtige Preisinfos

https://github.com/features/actions
Der Service ist „kostenlos“ bis zum Limit, abhängig von der gewählten Maschine.
Wir werden eine macOS Maschine nutzen; im Screenshot siehst du den Preis und die Limits (Preise zum Zeitpunkt der Tutorial-Erstellung, Änderungen vorbehalten).
🔴 Nachdem Anforderungen und Preise geklärt sind, machen wir weiter, wenn du möchtest…
📣 In diesem Beitrag gehen wir davon aus, dass die App in iTunes Connect erstellt wurde und wir über die Zertifikate des Apple-Ökosystems verfügen. Alles wird von Fastlane kopiert!
Tauchen wir ein 🤿
Schritte im Beitrag
- App Store Connect API mit Fastlane Match
- Anforderungen
- App Store Connect API Key erstellen
- Einen App Store Connect API Key verwenden
- Fastlane-Dateien kopieren
- Fastlane match konfigurieren
1. App Store Connect API mit Fastlane match nutzen
Seit Februar 2021 ist für alle Nutzer eine Zwei-Faktor-Authentifizierung oder eine Zwei-Schritt-Verifizierung erforderlich, um sich bei App Store Connect anzumelden. Diese zusätzliche Sicherheitsebene für Ihre Apple ID hilft sicherzustellen, dass nur Sie auf Ihr Konto zugreifen können.
Von Apple-Support
Um mit match zu starten, müssen Sie Ihre bestehenden Zertifikate widerrufen. Aber keine Sorge, Sie erhalten direkt neue.
Anforderungen
Um App Store Connect API nutzen zu können, benötigt Fastlane drei Dinge.
- Issuer-ID.
- die Key ID.
- die Key-Datei oder den Key-Inhalt.
App Store Connect API Key erstellen
Um Keys zu generieren, benötigst du Admin-Rechte in App Store Connect. Falls du sie nicht hast, kannst du die zuständige Person auf diesen Artikel verweisen und die folgenden Anweisungen befolgen.
1 — Anmelden bei App Store Connect.
2 — Auswählen Benutzer und Zugriff.

3 — Wählen Sie den Tab Integration aus.

4 — Klicke auf Generate API Key oder den Add (+)-Button.

5 — Geben Sie einen Namen für den Schlüssel ein. Der Name dient nur als Referenz für Sie und ist nicht Teil des Schlüssels selbst.

6 — Wählen Sie unter Zugriff die Rolle für den Schlüssel aus. Die Rollen, die für Schlüssel gelten, sind dieselben wie für Benutzer in Ihrem Team. Siehe Rollenberechtigungen. Wir empfehlen die Auswahl von App-Manager.
7 — Klicken Sie auf Generieren.
Der Zugriff eines API Keys kann nicht auf bestimmte Apps beschränkt werden.
Der Name des neuen Keys, die Key-ID, ein Download-Link und weitere Infos werden auf der Seite angezeigt.

Alle drei benötigten Informationen findest du hier.
<1> Issue-ID.
<2> Key-ID.
<3> Klicke auf „Download API Key“, um deinen API Private Key herunterzuladen. Der Download-Link erscheint nur, wenn der Private Key noch nicht heruntergeladen wurde. Apple speichert keine Kopie des Private Keys. Du kannst ihn also nur einmal herunterladen.
🔴 Speichere deinen Private Key an einem sicheren Ort. Du solltest deine Keys niemals teilen, sie nicht in einem code-Repository speichern oder in clientseitigem code einbinden.
Einen App Store Connect API Key verwenden
Die API Key-Datei (die p8-Datei, die du herunterlädst), die Key ID und die Issuer ID brauchst du, um das JWT-Token für die Autorisierung zu erstellen. Es gibt mehrere Wege, diese Informationen über die neue Fastlane-Action an Fastlane zu übergeben, app_store_connect_api_key. Weitere Methoden findest du in der Fastlane-Dokumentation. Ich zeige diese Methode, weil sie meiner Meinung nach am einfachsten mit den meisten CI-Systemen funktioniert, bei denen man Umgebungsvariablen setzen kann.
Jetzt können wir Fastlane mit dem App Store Connect API Key verwalten, super!
2. Fastlane-Dateien kopieren
Fastlane ist eine Ruby-Library, mit der sich gängige Aufgaben in der Mobile-Entwicklung automatisieren lassen. Mit Fastlane kannst du eigene „Lanes“ konfigurieren, die eine Reihe von „Actions“ bündeln, um Aufgaben auszuführen, die du normalerweise in Android Studio erledigst. Mit Fastlane lässt sich viel erreichen, aber in diesem Tutorial nutzen wir nur eine Handvoll Core-Actions.
Erstellen Sie einen Fastlane-Ordner im Projektstamm und kopieren Sie die folgenden Dateien: Fastfile
default_platform(:ios)
DEVELOPER_APP_IDENTIFIER = ENV["DEVELOPER_APP_IDENTIFIER"]
DEVELOPER_APP_ID = ENV["DEVELOPER_APP_ID"]
PROVISIONING_PROFILE_SPECIFIER = ENV["PROVISIONING_PROFILE_SPECIFIER"]
TEMP_KEYCHAIN_USER = ENV["TEMP_KEYCHAIN_USER"]
TEMP_KEYCHAIN_PASSWORD = ENV["TEMP_KEYCHAIN_PASSWORD"]
APPLE_ISSUER_ID = ENV["APPLE_ISSUER_ID"]
APPLE_KEY_ID = ENV["APPLE_KEY_ID"]
APPLE_KEY_CONTENT = ENV["APPLE_KEY_CONTENT"]
GIT_USERNAME = ENV["GIT_USERNAME"]
GIT_TOKEN = ENV["GIT_TOKEN"]
def delete_temp_keychain(name)
delete_keychain(
name: name
) if File.exist? File.expand_path("~/Library/Keychains/#{name}-db")
end
def create_temp_keychain(name, password)
create_keychain(
name: name,
password: password,
unlock: false,
timeout: 0
)
end
def ensure_temp_keychain(name, password)
delete_temp_keychain(name)
create_temp_keychain(name, password)
end
platform :ios do
lane :build do
build_app(
configuration: "Release",
workspace: "./ios/App/App.xcworkspace",
scheme: "App",
export_method: "app-store",
export_options: {
provisioningProfiles: {
DEVELOPER_APP_ID => "#{PROVISIONING_PROFILE_SPECIFIER}"
}
}
)
end
lane :refresh_profiles do
match(
type: "development",
force: true)
match(
type: "adhoc",
force: true)
end
desc "Register new device"
lane :register_new_device do |options|
device_name = prompt(text: "Enter the device name: ")
device_udid = prompt(text: "Enter the device UDID: ")
device_hash = {}
device_hash[device_name] = device_udid
register_devices(
devices: device_hash
)
refresh_profiles
end
lane :closed_beta do
keychain_name = TEMP_KEYCHAIN_USER
keychain_password = TEMP_KEYCHAIN_PASSWORD
ensure_temp_keychain(keychain_name, keychain_password)
api_key = app_store_connect_api_key(
key_id: APPLE_KEY_ID,
issuer_id: APPLE_ISSUER_ID,
key_content: APPLE_KEY_CONTENT,
duration: 1200,
in_house: false
)
match(
type: 'appstore',
git_basic_authorization: Base64.strict_encode64("#{GIT_USERNAME}:#{GIT_TOKEN}"),
readonly: true,
keychain_name: keychain_name,
keychain_password: keychain_password,
api_key: api_key
)
gym(
configuration: "Release",
workspace: "./ios/App/App.xcworkspace",
scheme: "App",
export_method: "app-store",
export_options: {
provisioningProfiles: {
DEVELOPER_APP_ID => "#{PROVISIONING_PROFILE_SPECIFIER}"
}
}
)
pilot(
apple_id: "#{DEVELOPER_APP_ID}",
app_identifier: "#{DEVELOPER_APP_IDENTIFIER}",
skip_waiting_for_build_processing: true,
skip_submission: true,
distribute_external: false,
notify_external_testers: false,
ipa: "./App.ipa"
)
delete_temp_keychain(keychain_name)
end
lane :submit_review do
version = ''
Dir.chdir("..") do
file = File.read("package.json")
data = JSON.parse(file)
version = data["version"]
end
deliver(
app_version: version,
submit_for_review: true,
automatic_release: true,
force: true, # Skip HTMl report verification
skip_metadata: false,
skip_screenshots: false,
skip_binary_upload: true
)
end
end
Appfile
app_identifier(ENV["DEVELOPER_APP_IDENTIFIER"])
apple_id(ENV["FASTLANE_APPLE_ID"])
itc_team_id(ENV["APP_STORE_CONNECT_TEAM_ID"])
team_id(ENV["DEVELOPER_PORTAL_TEAM_ID"])
Fastlane match konfigurieren
Fastlane match ist ein neuer Ansatz für das code-Signing unter iOS. Fastlane match erleichtert Teams die Verwaltung der erforderlichen Zertifikate und Provisioning-Profile für Ihre iOS-Apps.
Neues privates Repository mit dem Namen certificates, z. B. auf Ihrem GitHub-Persönlichen Konto oder in Ihrer Organisation.
Initialisieren Sie Fastlane match für Ihre iOS-App.
fastlane match init
Wählen Sie dann Option #1 (Git Storage).
[01:00:00]: fastlane match supports multiple storage modes, please select the one you want to use:1. git2. google_cloud3. s3?
Weisen Sie die URL des neu erstellten Repositories zu.
[01:00:00]: Please create a new, private git repository to store the certificates and profiles there[01:00:00]: URL of the Git Repo: <YOUR_CERTIFICATES_REPO_URL>
Im Fastlane-Ordner finden Sie nun eine Datei namens Matchfile und
_git_url_auf die HTTPS-URL des Zertifikat-Repositories gesetzt werden sollte. Optional können Sie auch SSH verwenden, dies erfordert jedoch einen anderen Ausführungsschritt.
# ios/Matchfilegit_url("https://github.com/gitusername/certificates")storage_mode("git")type("appstore")
Als Nächstes generieren wir die Zertifikate und geben bei der Aufforderung Ihre Zugangsdaten für Fastlane Match ein.
Du wirst aufgefordert, eine Passphrase einzugeben. Merke sie dir genau, da sie später von GitHub Actions verwendet wird, um dein Zertifikats-Repository zu entschlüsseln.
fastlane match appstore
Wenn alles geklappt hat, siehst du etwas Ähnliches:
[01:40:52]: All required keys, certificates and provisioning profiles are installed 🙌
Falls du Probleme mit GitHub und den erforderlichen Berechtigungen hattest, hilft vielleicht dieser Beitrag dir, Authentifizierungs-Tokens für Git zu generieren.
Generierte Zertifikate und Provisioning-Profile werden in die Ressourcen des Zertifikate-Repositories hochgeladen

Öffne abschließend deine project in Xcode und aktualisiere das Provisioning-Profil für die Release-Konfiguration deiner App.

Ein paar Hinweise 💡
TREFFER
Damit die CI/CD die Zertifikate und Provisioning-Profile importieren kann, braucht sie Zugriff auf das Zertifikate-Repository. Erstelle dafür ein Personal Access Token (das vorher verwendet werden sollte) mit der Berechtigung, auf private Repositories zuzugreifen oder sie zu lesen.
Gehe in GitHub zu Einstellungen → Entwicklereinstellungen → Personal Access Tokens → klicken Generate New Token → tick the repo Scope → dann klicken Generate token.

Eine Kopie des generierten persönlichen Access-Tokens aufbewahren. Du wirst ihn später für die Umgebungsvariable verwenden. GIT_TOKEN.
Ersetze dann deine in Fastlane generierte match-Datei durch Matchfile
CERTIFICATE_STORE_URL = ENV["CERTIFICATE_STORE_URL"]
GIT_USERNAME = ENV["GIT_USERNAME"]
GIT_TOKEN = ENV["GIT_TOKEN"]
FASTLANE_APPLE_ID = ENV["FASTLANE_APPLE_ID"]
git_url(CERTIFICATE_STORE_URL)
storage_mode("git")
type("appstore")
git_basic_authorization(Base64.strict_encode64("#{GIT_USERNAME}:#{GIT_TOKEN}"))
username(FASTLANE_APPLE_ID)
Dies wird von GitHub Actions verwendet, um die Zertifikate und Provisioning-Profile zu importieren. Und var wird in GitHub Secrets gesetzt, anstatt sie in der Datei hart zu coden.
Build-Verarbeitung
In GitHub Actions wird nach den verbrauchten Minuten abgerechnet, die du für die Ausführung deines CI/CD-Workflows genutzt hast. Erfahrungsgemäß dauert es etwa 10–15 Minuten, bis ein Build in App Store Connect verarbeitet werden kann.
Bei privaten Projekten können die geschätzten Kosten pro Build bis zu $0,08/Min. x 15 Min. = $1,20, oder mehr, je nach Konfiguration oder Abhängigkeiten deines Projekts.
Falls du dir bei der Preisgestaltung dieselben Sorgen machst wie ich bei privaten Projekten, kannst du skip_waiting_for_build_processing zu true.
Wo ist der Haken? Du musst die Compliance deiner App in App Store Connect manuell aktualisieren, nachdem der Build verarbeitet wurde, damit du den Build an deine Nutzer verteilen kannst.
Das ist nur ein optionaler Parameter, den du aktualisieren kannst, wenn du bei privaten Projekten Build-Minuten sparen willst. Bei kostenlosen Projekten sollte das gar kein Problem sein. Siehe Preise.
3. GitHub Actions einrichten
GitHub Secrets konfigurieren
Hast du dich schon mal gefragt, woher die Werte von ENV kommen? Kein Geheimnis mehr – sie stammen aus dem Secret deines Projekts. 🤦

1. APP_STORE_CONNECT_TEAM_ID - die ID deines App Store Connect Teams, falls du in mehreren Teams bist.
2. DEVELOPER_APP_ID - gehe in App Store Connect zur App → App-Informationen → Scrolle nach unten zum General Information Bereich deiner App und suche nach Apple ID.
3. DEVELOPER_APP_IDENTIFIER - dem Bundle Identifier deiner App.
4. DEVELOPER_PORTAL_TEAM_ID - der ID deines Developer-Portal-Teams, falls du in mehreren Teams bist.
5. FASTLANE_APPLE_ID - der Apple ID oder der Entwickler-E-Mail, mit der du die App verwaltest.
6. GIT_USERNAME & GIT_TOKEN - deinem Git-Benutzernamen und deinem Personal Access Token.
7. MATCH_PASSWORD - der Passphrase, die du bei der Initialisierung von match vergeben hast; sie wird zum Entschlüsseln der Zertifikate und Provisioning Profiles verwendet.
8. PROVISIONING_PROFILE_SPECIFIER - match AppStore <YOUR_APP_BUNDLE_IDENTIFIER>, z. B. match AppStore com.domain.blabla.demo.
9. TEMP_KEYCHAIN_USER & TEMP_KEYCHAIN_PASSWORD - weise deinem Workflow einen temporären Keychain-User und ein Passwort zu.
10. APPLE_KEY_ID — App Store Connect API Key 🔺Key ID.
11. APPLE_ISSUER_ID — App Store Connect API Key 🔺Issuer ID.
12. APPLE_KEY_CONTENT — App Store Connect API Key 🔺 Key-Datei oder Key-Inhalt von .p8, Prüfen
13. CERTIFICATE_STORE_URL — Die Repo-URL deiner Match-Keys (z. B.: https://github.com/***/fastlane_match.git)
4. GitHub Workflow-Datei konfigurieren
Erstelle ein GitHub Workflow-Verzeichnis.
cd .github/workflows
Im workflow Ordner erstelle eine Datei namens build-upload-ios.ymlund füge Folgendes hinzu.
name: Build source code on ios
on:
push:
tags:
- '*'
jobs:
build_ios:
runs-on: macOS-latest
steps:
- uses: actions/checkout@v6
- name: set Node.js
uses: actions/setup-node@v6
with:
node-version: '24'
cache: npm
- name: Install dependencies
id: install_code
run: npm ci
- name: Build
id: build_code
run: npm run build
- uses: actions/cache@v5
with:
path: ios/App/Pods
key: ${{ runner.os }}-pods-${{ hashFiles('**/Podfile.lock') }}
restore-keys: |
${{ runner.os }}-pods-
- name: Sync
id: sync_code
run: npx cap sync
- uses: ruby/setup-ruby@v1
with:
ruby-version: 2.7.2
- uses: maierj/fastlane-action@v2.3.0
env:
DEVELOPER_APP_IDENTIFIER: ${{ secrets.DEVELOPER_APP_IDENTIFIER }}
DEVELOPER_APP_ID: ${{ secrets.DEVELOPER_APP_ID }}
PROVISIONING_PROFILE_SPECIFIER: match AppStore ${{ secrets.DEVELOPER_APP_IDENTIFIER }}
TEMP_KEYCHAIN_USER: ${{ secrets.TEMP_KEYCHAIN_USER }}
TEMP_KEYCHAIN_PASSWORD: ${{ secrets.TEMP_KEYCHAIN_PASSWORD }}
APPLE_ISSUER_ID: ${{ secrets.APPLE_ISSUER_ID }}
APPLE_KEY_ID: ${{ secrets.APPLE_KEY_ID }}
APPLE_KEY_CONTENT: ${{ secrets.APPLE_KEY_CONTENT }}
CERTIFICATE_STORE_URL: https://github.com/${{ secrets.CERTIFICATE_STORE_REPO }}.git
GIT_USERNAME: ${{ secrets.GIT_USERNAME }}
GIT_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
FASTLANE_APPLE_ID: ${{ secrets.FASTLANE_APPLE_ID }}
MATCH_USERNAME: ${{ secrets.FASTLANE_APPLE_ID }}
MATCH_PASSWORD: ${{ secrets.MATCH_PASSWORD }}
APP_STORE_CONNECT_TEAM_ID: ${{ secrets.APP_STORE_CONNECT_TEAM_ID }}
DEVELOPER_PORTAL_TEAM_ID: ${{ secrets.DEVELOPER_PORTAL_TEAM_ID }}
with:
lane: closed_beta
- name: Upload release bundle
uses: actions/upload-artifact@v2
with:
name: ios-release
path: ./App.ipa
retention-days: 60
Dieser Workflow sollte nach jedem GitHub ausgelöst werden Tag, falls du das Tagging automatisieren möchtest, schau bitte in Automatischer Build und Release mit GitHub Actions zuerst.
Anschließend lädt dieser Workflow deine NodeJS-Abhängigkeiten herunter, installiert sie und baut deine JavaScript-App.
Jedes Mal, wenn du einen neuen Commit pushst, wird ein Release in TestFlight erstellt.
Deine App muss nicht Ionic nutzen, nur die Capacitor Basis ist Pflicht. Sie kann alte Cordova-Module enthalten, aber Capacitor JS-Plugins sollten bevorzugt werden.
5. Workflow triggern
Einen Commit erstellen
Erstelle einen Commit, dann solltest du den aktiven Workflow im Repository sehen.
Workflow auslösen
Neue Commits in den Branch pushen main oder development um den Workflow auszulösen.

Nach wenigen Minuten sollte der Build in deinem App Store Connect Dashboard verfügbar sein.

Deployment vom lokalen Rechner möglich?
Ja, das geht und ist absolut mühelos.
Stell dir vor, du hast ein privates Repository, die Minuten des Free-Plans sind aufgebraucht und du willst nicht für neue Releases zahlen – oder du reichst die App lieber manuell ein.
Legen wir los
Ok, zuerst müssen wir in my_project_path/fastlane Pfad einer Datei namens .env, einfach im selben Pfad wie Fastfile, um dieselben zu erstellen Secret- Eigenschaften wie in unserem _GitHub zu erstellen, siehe unten:
.env-Datei für den Deploy von der lokalen Maschine
Jetzt kannst du in die Terminal und starten Fastlane von deinem Rechner:
fastlane closed_beta
❌ Wichtig bei der .env Datei: Da wir diese Daten lieber nicht preisgeben, müssen wir sie in unsere .gitignoreeintragen, etwa so: ❌
fastlane/*.env
Es sollte genauso funktionieren wie über GitHub Actions auf dem Remote-Server, nur eben auf unserem lokalen Rechner. 🍻

Terminal-Befehl: $ Fastlane closed_beta
Wenn du bis hierher gekommen bist: Glückwunsch! Du hast nun einen vollautomatisierten Prozess für deine iOS-Apps mit Fastlane und GitHub Actions.
Jedes Mal, wenn du einen neuen Commit pushst, wird ein Release in der Google Play Console im Beta-Channel gebaut. Ich werde diesen Blogpost basierend auf eurem Feedback verbessern. Falls ihr Fragen oder Anregungen habt, schreibt mir einfach eine E-Mail. martin@capgo.app
Auf deinem Gerät builden
Wenn du weiterhin auf deinem Gerät builden musst, musst du sie manuell zum Provisioning hinzufügen.
Verbinde dein Gerät mit deinem Mac und öffne das Geräte-Menü
Kopiere dann deinen Identifier
Und starte dann den Befehl:
fastlane register_new_device
Du wirst nach einem Gerätenamen und dem Identifier gefragt:

Falls Probleme auftreten
Wenn es Probleme gibt, weil das Dev-Gerät nicht testen kann usw., behebt das das meistens.
Es gibt einen magischen Befehl, der dich retten kann:
fastlane match nuke development
fastlane match development
Dann: Reinige das Projekt, indem du Shift(⇧)+Command(⌘)+K hältst oder Produkt > Reinigen wählst (es kann auch als „Build-Ordner reinigen“ bezeichnet werden).
Versuche dann, die App erneut auf deinem Gerät auszuführen.
Danke
Dieser Blogpost basiert auf folgenden Artikeln:
- Continuous Delivery für iOS mit Fastlane und GitHub-Actions
- Fastlane-Dokumentation
- Diese GitHub Nachricht von @mrogunlana
Weiter mit dem automatischen Capacitor iOS-Build via GitHub Actions mit match
Wenn du es nutzt Automatisierter Capacitor iOS-Build mit GitHub Actions via match um CI/CD-Automatisierung zu planen, verbinde es mit Capgo CI/CD für den Produkt-Workflow in Capgo CI/CD, Capgo Native Builds optimieren für den Produkt-Workflow in Capgo Native Builds, Capgo Integrationen für den Produkt-Workflow in Capgo Integrations, CI/CD-Integration für die Implementierungsdetails in der CI/CD-Integration und GitHub Actions-Integration für die Implementierungsdetails in der GitHub Actions-Integration.