> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devinenterprise.com/llms.txt
> Use this file to discover all available pages before exploring further.

# GitHub

> Arbeiten Sie direkt in Ihren Repositories mit Devin

<div id="why-integrate-devin-with-github">
  ## Warum Devin mit GitHub integrieren?
</div>

Die Integration von Devin mit deiner GitHub-Organisation ermöglicht es Devin, Pull Requests zu erstellen, auf PR-Kommentare zu antworten und direkt in deinen Repositories zusammenzuarbeiten. So kann Devin als vollwertiges Mitglied deines Engineering-Teams fungieren.

Um zu beginnen, gehe zu [app.devin.ai](http://app.devin.ai) > **Settings** > **Integrations** > **GitHub**, klicke auf **Add Connection** und folge den Anweisungen. Dabei wählst du aus, auf welche Repositories Devin zugreifen kann, und überprüfst die erforderlichen Berechtigungen.

<Note>
  **Verwendest du GitHub Enterprise Server oder GitHub Enterprise Cloud mit Data Residency?** Siehe den [GitHub Enterprise Server Integrationsleitfaden](/de/enterprise/integrations/github-enterprise-server) für Einrichtungsschritte.
</Note>

<div id="setting-up-the-integration">
  ## Einrichten der Integration
</div>

<Tip>Sie müssen Administrator Ihrer GitHub-Organisation sein, um die Devin-Integration zu erstellen und zu verwalten. Gibt es Probleme? Sehen Sie sich unsere Seite zu [häufigen Problemen](/de/admin/common-issues#i-m-unable-to-connect-my-github-organization) an.</Tip>

1. Melden Sie sich in Ihrem Devin-Konto unter [app.devin.ai](http://app.devin.ai) an, navigieren Sie zu **Settings** > **Integrations** > **GitHub** und klicken Sie auf **Add Connection**.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/c6DxxPyY6b7QnGkw/images/integrations/Add-GitHub-Connection.png?fit=max&auto=format&n=c6DxxPyY6b7QnGkw&q=85&s=c7f5f670bcf2216e6883b99fbb267f49" alt="Devin" width="1264" height="1474" data-path="images/integrations/Add-GitHub-Connection.png" />
</Frame>

2. Wenn Sie noch nicht bei GitHub angemeldet sind, werden Sie zur Authentifizierung aufgefordert.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/c6DxxPyY6b7QnGkw/images/integrations/GitHub-Authenticate.png?fit=max&auto=format&n=c6DxxPyY6b7QnGkw&q=85&s=22f091a1ffec12d41b28b7ac2e955a77" alt="Devin" width="1004" height="1380" data-path="images/integrations/GitHub-Authenticate.png" />
</Frame>

3. Wählen Sie die GitHub-Organisation aus, die Sie mit Devin verbinden möchten.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/c6DxxPyY6b7QnGkw/images/integrations/GitHub-Select-Organization.png?fit=max&auto=format&n=c6DxxPyY6b7QnGkw&q=85&s=84eb317b909b6a1a4ab70742563a1eec" alt="Devin" width="1296" height="726" data-path="images/integrations/GitHub-Select-Organization.png" />
</Frame>

4. Wählen Sie aus, ob Sie Devin Zugriff auf **All repositories** oder **Select repositories** gewähren möchten, um zu steuern, auf welche Repositories Devin zugreifen kann.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/c6DxxPyY6b7QnGkw/images/integrations/GitHub-Grant-Repository-Permissions.png?fit=max&auto=format&n=c6DxxPyY6b7QnGkw&q=85&s=26c759c0d5fa426677ab3fa765a49952" alt="Devin" width="1004" height="652" data-path="images/integrations/GitHub-Grant-Repository-Permissions.png" />
</Frame>

5. Nach Abschluss der GitHub-Autorisierung werden Sie zu den Devin-Einstellungen weitergeleitet, wo Sie überprüfen können, dass die Integration aktiv ist.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/c6DxxPyY6b7QnGkw/images/integrations/GitHub-Connected.png?fit=max&auto=format&n=c6DxxPyY6b7QnGkw&q=85&s=0381c62ef505b76d57ec7924614e45b6" alt="Devin" width="1212" height="326" data-path="images/integrations/GitHub-Connected.png" />
</Frame>

<Tip>Wir empfehlen, Branch-Schutzregeln auf Ihrem Main-Branch zu aktivieren, um sicherzustellen, dass alle erforderlichen Checks erfolgreich sind, bevor Devin Änderungen mergen kann.</Tip>

<div id="using-devin-with-the-github-integration">
  ## Verwendung von Devin mit der GitHub-Integration
</div>

<div id="for-core-and-teams-users">
  ### Für Core- und Teams-Nutzer
</div>

Sobald die Integration konfiguriert ist, können Sie Repositories direkt in Ihren Prompts in der Devin-Webanwendung per @mention referenzieren.

<div id="for-enterprise-users">
  ### Für Enterprise-Kunden
</div>

Sobald die Integration eingerichtet ist, können Sie Repositories über **Enterprise Settings** > **Repository Permissions** bestimmten Organisationen zuordnen.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/Mjnq1XQhhDt7kgxn/images/enterprise/Enterprise-Add-Repositories.png?fit=max&auto=format&n=Mjnq1XQhhDt7kgxn&q=85&s=40569aced6bfea47b72b31a39865b89f" alt="Devin" width="2360" height="1322" data-path="images/enterprise/Enterprise-Add-Repositories.png" />
</Frame>

<Tip>
  Wenn Sie zum ersten Mal mit einem Repository arbeiten, empfehlen wir, die [Einrichtung der Entwicklungsumgebung im Onboarding-Flow](/de/onboard-devin/environment) abzuschließen, um sicherzustellen, dass Devin über präzise,
  aktuelle Informationen zu Ihrer Codebasis verfügt. Devin beantwortet PR-Kommentare automatisch, solange die Sitzung nicht archiviert wurde.
</Tip>

<div id="managing-devins-permissions-in-github">
  ## Verwalten von Devins Berechtigungen in GitHub
</div>

Während der Einrichtung kannst du Devin Zugriff auf **alle Repositories** in deiner Organisation gewähren oder den Zugriff auf **bestimmte Repositories** beschränken.

Du kannst den Repository-Zugriff jederzeit über die Einstellungen von GitHub anpassen:

1. Navigiere zu den **Settings** > **GitHub Apps** deiner GitHub-Organisation (z. B. `https://github.com/organizations/<org_name>/settings/installations`)
2. Wähle **Configure** für die Devin.ai-Integration aus
3. Wähle unter **Repository access**, ob du Zugriff auf alle Repositories gewähren oder bestimmte Repositories auswählen möchtest
4. Klicke auf **Save**, um deine Änderungen zu übernehmen

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/c6DxxPyY6b7QnGkw/images/integrations/GitHub-Manage-Devin-Permissions.png?fit=max&auto=format&n=c6DxxPyY6b7QnGkw&q=85&s=f926780257bb9628e26d634f4a15c18c" alt="Devin" width="1984" height="1542" data-path="images/integrations/GitHub-Manage-Devin-Permissions.png" />
</Frame>

Devin benötigt die folgenden Berechtigungen:

**Lese**zugriff auf:

| Berechtigung                     | Beschreibung                                                                                                                                               |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `dependabot alerts`              | Ermöglicht Devin, Dependabot-Warnungen in deinem Namen zu beheben (d. h. Aktualisieren von Abhängigkeitsversionen)                                         |
| `actions`                        | Ermöglicht Devin, die für ein Repository konfigurierten Actions einzusehen, um zu verstehen, ob Devins Änderungen die CI-Prüfungen erfolgreich durchlaufen |
| `deployments`                    | Ermöglicht Devin zu sehen, welche Versionen eines Repositories bereitgestellt wurden                                                                       |
| `metadata`                       | Ermöglicht Devin, wichtige Metadaten zu einem Repository einzusehen, z. B. wer es besitzt                                                                  |
| `packages`                       | Ermöglicht Devin zu sehen, welche Versionen eines Repositories als Paket ausgeliefert wurden                                                               |
| `pages`                          | Ermöglicht Devin, mit einem Repository verknüpfte Pages zu konsultieren, z. B. um Dokumentation einzusehen                                                 |
| `repository security advisories` | Ermöglicht Devin, sicherheitsrelevante Hinweise zu einem Repository einzusehen, um bei der Behebung von Sicherheitsproblemen zu helfen                     |
| `members`                        | Ermöglicht Devin, Mitglieder einer Organisation einzusehen                                                                                                 |
| `webhooks`                       | Ermöglicht Devin, die für ein Repository konfigurierten Webhooks einzusehen, z. B. Linting und Typprüfungen                                                |

**Lese**- und **Schreib**zugriff auf:

| Berechtigung      | Beschreibung                                                                                                                                                                            |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `checks`          | Ermöglicht Devin, die Check-Ergebnisse für ein Repository einzusehen und zu melden, um zu verstehen und zu kommunizieren, ob Devins Änderungen die CI-Prüfungen erfolgreich durchlaufen |
| `commit statuses` | Ermöglicht Devin, Commit-Status einzusehen und zu setzen, um anzugeben, ob ein Commit die CI-Prüfungen erfolgreich durchläuft                                                           |
| `contents`        | Ermöglicht Devin, zur Codebasis beizutragen                                                                                                                                             |
| `discussions`     | Ermöglicht Devin, zu Discussions beizutragen                                                                                                                                            |
| `issues`          | Ermöglicht Devin, neue Issues zu eröffnen                                                                                                                                               |
| `pull requests`   | Ermöglicht Devin, neue PRs zu erstellen                                                                                                                                                 |
| `projects`        | Ermöglicht Devin, mit einem Repository verknüpfte Projekte einzusehen und zu verwalten, z. B. um Informationen zu einer Aufgabe abzurufen                                               |
| `workflows`       | Ermöglicht Devin, neue Workflows einzurichten, z. B. zur Unterstützung bei der Konfiguration von CI/CD                                                                                  |

Diese Berechtigungen ermöglichen es Devin, in deinen Repositories wie ein regulärer Contributor zu arbeiten – Branches zu pushen, Pull Requests zu eröffnen und sich an PR-Diskussionen zu beteiligen.

<div id="pull-request-templates">
  ## Pull-Request-Vorlagen
</div>

Wenn Devin einen Pull-Request erstellt, verwendet es eine Vorlage aus deinem Repository, um die PR-Beschreibung zu strukturieren. Wenn du eine Vorlage bereitstellst, hält sich Devin an deren Format, wenn es PRs auf GitHub einreicht.

<div id="devin-specific-template-recommended">
  ### Devin-spezifische Vorlage (empfohlen)
</div>

Sie können Devin eine eigene Vorlage zur Verfügung stellen, ohne Ihre standardmäßige, auf Menschen ausgerichtete Vorlage zu ändern, indem Sie eine Datei mit dem Namen `devin_pr_template.md` an einem der unten aufgeführten unterstützten `PULL_REQUEST_TEMPLATE`-Speicherorte hinzufügen. Das ist hilfreich, wenn Sie möchten, dass Devin zusätzlichen Kontext einbezieht, zum Beispiel eine Review-Checkliste oder ein Mermaid-Diagramm der geänderten Dateien.

<div id="template-search-order">
  ### Reihenfolge der Vorlagensuche
</div>

Devin sucht in der folgenden Reihenfolge nach Vorlagen und verwendet den ersten Treffer:

1. PULL\_REQUEST\_TEMPLATE/devin\_pr\_template.md
2. docs/PULL\_REQUEST\_TEMPLATE/devin\_pr\_template.md
3. .github/PULL\_REQUEST\_TEMPLATE/devin\_pr\_template.md
4. pull\_request\_template.md
5. docs/pull\_request\_template.md
6. .github/pull\_request\_template.md

Wenn keine Vorlage gefunden wird, greift Devin auf sein internes Standardformat für PR-Beschreibungen zurück.

<Tip>Wenn du möchtest, dass Devin deine vorhandene `pull_request_template.md` verwendet, kopiere sie in einen der oben aufgeführten `devin_pr_template.md`-Pfade oder erstelle einen Symlink darauf.</Tip>

<Info>Weitere Informationen zu GitHub-Pull-Request-Vorlagen (unterstützte Speicherorte, mehrere Vorlagen, Query-Parameter usw.) findest du in den GitHub Docs: <a href="https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/creating-a-pull-request-template-for-your-repository" target="_blank" rel="noopener noreferrer">Creating a pull request template for your repository</a>.</Info>

<div id="commit-signing">
  ### Commit-Signierung
</div>

Um Devins Commits mit GPG zu signieren, konfigurieren Sie den Schlüssel in Ihrer [Umgebung](/de/onboard-devin/environment/blueprints), damit er sitzungsübergreifend erhalten bleibt. Das Generieren des Schlüssels in einem Sitzungs-Terminal funktioniert nicht — jede Devin-Sitzung startet mit einer frischen Kopie des Maschinenabbilds, sodass alle während der Sitzung erstellten Schlüssel verworfen werden, wenn die Sitzung endet.

<Warning>
  GPG-Signierung über die Umgebungskonfiguration erzeugt nur dann **Verified**-Commits, wenn
  Devin der *Commit-Autor* ist. GitHub verifiziert Signaturen anhand der Autor-
  Identität. In jedem **Commit authoring**-Modus, in dem der Autor der
  anfragende Nutzer ist (z. B. „Co-authored“, „User only“, „User as author, Devin as
  committer“), überschreibt Devin `user.email` jedoch pro Sitzung mit der jeweiligen
  E-Mail-Adresse des Nutzers — und diese stimmt nicht mit einem einzelnen gemeinsam genutzten GPG-Schlüssel überein. Setzen Sie den [Commit
  authoring](https://app.devin.ai/settings/profile)-Modus Ihrer Org auf **„Devin only“** oder
  **„Devin as author, user as committer“**, bevor Sie sich auf dieses Setup verlassen.
</Warning>

Richten Sie dies auf der **org-weiten** Schicht ein (oder auf der **Enterprise**-Schicht, wenn alle Ihre Orgs dies benötigen), damit jedes Repo eine Konfiguration für signierte Commits erhält:

1. Erstellen Sie ein dediziertes GitHub-Nutzerkonto (oder wählen Sie eines aus), das sowohl die Commit-Autor-Identität *als auch* die Zugangsdaten besitzt, mit denen Devin pusht — z. B. `devin@company.com`. Wenn Sie für beides ein Konto verwenden, ist die Signatur-Einrichtung unkompliziert; bei zwei Konten verteilt sich die unten beschriebene Konfiguration auf beide.
2. Generieren Sie lokal einen GPG-Schlüssel mit der E-Mail-Adresse dieses Kontos als UID und folgen Sie dabei den [Anweisungen von GitHub](https://docs.github.com/en/authentication/managing-commit-signature-verification/generating-a-new-gpg-key).
3. Laden Sie den **öffentlichen** Schlüssel in das GitHub-Konto hoch, dessen verifizierte E-Mail mit der GPG-UID übereinstimmt, unter [GitHub Settings > SSH and GPG keys](https://github.com/settings/keys). GitHub verifiziert Signaturen anhand der Identität des *Commit-Autors*, nicht anhand der Identität, die pusht — der öffentliche Schlüssel muss auf dem Konto hinterlegt sein, dem die E-Mail in `user.email` gehört. (Wenn das dasselbe dedizierte Konto ist, mit dem Sie pushen, müssen Sie dies nur einmal tun.)
4. Exportieren Sie den **privaten** Schlüssel, kodieren Sie ihn mit Base64 und fügen Sie ihn (zusammen mit den passenden `GIT_USER_NAME` / `GIT_USER_EMAIL`) als Secrets in [Settings > Secrets](https://app.devin.ai/settings/secrets) hinzu.
5. Importieren Sie in Ihrer [org-weiten Umgebungskonfiguration](https://app.devin.ai/settings/environment) den Schlüssel und aktivieren Sie die Signierung bei jedem Sitzungsstart. Das vollständige YAML finden Sie im Copy-paste-[Beispiel für GPG-Commit-Signierung](/de/onboard-devin/environment/templates#gpg-commit-signing).

<Tip>
  Die Committer-E-Mail (`user.email`) muss mit einer UID auf dem GPG-Schlüssel übereinstimmen, und dieselbe
  E-Mail muss als verifizierte E-Mail-Adresse im GitHub-Konto hinterlegt sein, in das Sie den
  öffentlichen Schlüssel hochgeladen haben. Wenn eine dieser drei Angaben nicht übereinstimmt, zeigt GitHub den Commit
  als **Unverified** an, auch wenn die Signatur selbst gültig ist.
</Tip>

<div id="security-considerations">
  ### Sicherheitsaspekte
</div>

* **Branchschutz:** Wir empfehlen, Branchschutzregeln auf Ihrem Haupt-Branch zu aktivieren, um sicherzustellen, dass alle erforderlichen Prüfungen erfolgreich abgeschlossen sind, bevor Devin Änderungen zusammenführen kann.
* **Berechtigungen auf Organisationsebene:** Devin verwendet die auf Organisationsebene gewährten Berechtigungen, nicht die Berechtigungen des einzelnen Benutzers, der eine Sitzung ausführt.
* **Einheitlicher Zugriff:** Alle Benutzer mit Zugriff sowohl auf die GitHub- als auch auf die Devin-Organisation verfügen über dieselben Devin-Integrationsberechtigungen.
* **Repository-Erstellung:** Devin kann in Ihrem GitHub-Konto keine neuen Repositories erstellen.

<div id="ip-allowlisting">
  ## IP-Allowlisting
</div>

Wenn Ihre Organisation IP-Allowlisting für den Zugriff auf GitHub erfordert, fügen Sie die folgenden IP-Adressen hinzu:

* 100.20.50.251
* 44.238.19.62
* 52.10.84.81
* 52.183.72.253
* 20.172.46.235
* 52.159.232.99
* 4.204.199.103
* 54.201.200.193
* 54.69.238.189
* 100.23.34.160

<Note>Diese IP-Adressen können sich in zukünftigen Updates ändern. Wir empfehlen, unsere Release Notes auf etwaige Änderungen zu prüfen.</Note>

<div id="troubleshooting-github-organization-connected-to-the-wrong-devin-organization">
  ## Fehlerbehebung: GitHub-Organisation ist mit der falschen Devin-Organisation verbunden
</div>

Wenn Ihre GitHub-Organisation bereits mit einer Devin-Organisation verbunden ist, auf die Sie keinen Zugriff haben, kann ein GitHub-Organisationsadministrator die bestehende Installation entfernen und sie unter einer anderen Devin-Organisation neu installieren.

<Warning>Wir empfehlen, dies vor dem Entfernen der Installation mit dem Inhaber der aktuellen Devin-Organisation abzustimmen.</Warning>

1. Rufen Sie [github.com/settings/installations](https://github.com/settings/installations) auf und klicken Sie neben **Devin.ai Integration** auf **Configure**.

   Wechseln Sie bei Bedarf über das Dropdown-Menü **Go to settings page** oben rechts in den richtigen GitHub-Organisationskontext.

   <Frame>
     <img src="https://mintcdn.com/cognitionai-enterprise/Q55SWovKajVuWOnW/images/integrations/GitHub-Settings-Switch-Context.png?fit=max&auto=format&n=Q55SWovKajVuWOnW&q=85&s=2d3a5deeb2792ed3461c5e8f20261ac4" alt="GitHub-Settings-Kontext wechseln" width="788" height="192" data-path="images/integrations/GitHub-Settings-Switch-Context.png" />
   </Frame>

2. Scrollen Sie auf der Installationsseite zum Abschnitt **Danger zone** und klicken Sie auf **Uninstall**, um die Devin.ai Integration aus der GitHub-Organisation zu entfernen.

   <Frame>
     <img src="https://mintcdn.com/cognitionai-enterprise/Q55SWovKajVuWOnW/images/integrations/GitHub-Uninstall-App.png?fit=max&auto=format&n=Q55SWovKajVuWOnW&q=85&s=6ed985bca3524ea7a574a95752f7cea7" alt="Devin.ai Integration deinstallieren" width="1095" height="839" data-path="images/integrations/GitHub-Uninstall-App.png" />
   </Frame>

3. Kehren Sie zu [app.devin.ai](https://app.devin.ai) zurück und laden Sie die Seite neu. Sie können die GitHub-Integration jetzt unter Ihrer Devin-Organisation neu installieren.

<div id="github-integration-faqs">
  ## GitHub-Integration – FAQ
</div>

<AccordionGroup>
  <Accordion title="Kann ich mein persönliches GitHub-Konto mit dem Devin-Konto meiner Organisation verbinden?" icon="user">
    Ja, Sie können entweder eine GitHub-Organisation oder ein persönliches GitHub-Konto mit Ihrer Devin-Organisation verbinden. Wir empfehlen jedoch, das Konto zu verbinden, das über die passenden Berechtigungen verfügt, damit Devin auf die Repositorys zugreifen kann, die Ihr Team benötigt.
  </Accordion>

  <Accordion title="Wie verarbeitet die GitHub-App die Authentifizierung von Nutzern?" icon="shield-halved">
    Nur Nutzer, die Mitglieder der Organisation sind, die die GitHub-Integration installiert hat, können sie in ihren Devin-Sitzungen verwenden. Devin erhält Zugriff auf die GitHub-Integration basierend auf der Organisationszugehörigkeit des Nutzers.
  </Accordion>

  <Accordion title="Wie verwaltet und rotiert Devin Verschlüsselungsschlüssel?" icon="binary">
    Verschlüsselungsschlüssel werden von AWS KMS verwaltet und regelmäßig erneuert.
  </Accordion>
</AccordionGroup>