---
title: "GitHub Connector"
description: "Vollständiger Leitfaden zur GitHub-Integration für die Synchronisierung von Repository-Events, Issues, Pull Requests und Aktivitäten von Entwickler:innen mit Brevo über Tajo."
url: https://tajo.io/de/docs/connectors/custom/github/
markdown: https://tajo.io/de/docs/connectors/custom/github.md
lang: de-DE
robots: noindex
---

Beantrage frühzeitigen Zugang

Gib deinen Vornamen und deine geschäftliche E-Mail-Adresse ein. Wir senden dir einen Link, mit dem du deine Anfrage für den Tajo-Zugang bestätigst.

# GitHub Connector

Connector-Status: Geplant Noch nicht gebaut. Tajo betreibt diesen Connector heute nicht.

| Quellfeld | Zielfeld | Beispielwert |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Verbinde deine GitHub-Repositories über Tajo mit Brevo für Developer-Engagement-Tracking, Release-Benachrichtigungs-Workflows und Community-Aktivitätsmonitoring.

## Überblick

| Eigenschaft | Wert |
| --- | --- |
| **Plattform** | GitHub |
| **Kategorie** | Custom |
| **Einrichtungsaufwand** | Mittel |
| **Offizielle Integration** | Nein |
| **Synchronisierte Daten** | Events, Nutzer:innen, Repositories |
| **API-Typ** | REST API, GraphQL API |
| **Authentifizierung** | GitHub App / Personal Access Token / OAuth 2.0 |
| **Basis-URL** | `https://api.github.com` |
| **API-Version** | `2022-11-28` (header-basierte Versionierung) |

## Funktionen

- **Issue- und PR-Tracking** - Synchronisiere Issue- und Pull-Request-Events in Brevo-Kontaktverläufe
- **Release-Benachrichtigungen** - Löse Brevo-Kampagnen bei neuen Repository-Releases aus
- **Contributor-Synchronisierung** - Ordne GitHub-Contributor:innen Brevo-Kontakten zu, um Community-Engagement zu fördern
- **Star- und Fork-Tracking** - Überwache Popularitätsmetriken von Repositories
- **Webhook-Event-Weiterleitung** - Leite GitHub-Events an Brevo-Automatisierungen weiter
- **Repository-Katalog** - Synchronisiere Repository-Metadaten als Brevo-Katalogeinträge

## Voraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

1. Ein GitHub-Konto mit Zugriff auf die Ziel-Repositories
2. Eine GitHub-App oder ein Personal Access Token (Fine-Grained empfohlen)
3. Admin-Zugriff auf Repositories für die Webhook-Konfiguration
4. Ein Brevo-Konto mit API-Zugriff
5. Ein Tajo-Konto mit aktivem Abonnement

## Authentifizierung

GitHub unterstützt mehrere Authentifizierungsmethoden. Tajo empfiehlt die Verwendung von GitHub Apps für Zugriff auf Organisationsebene.

### Option 1: GitHub-App (Empfohlen)

1. Navigiere zu **Settings** > **Developer settings** > **GitHub Apps**
2. Klicke auf **New GitHub App**
3. Konfiguriere die App mit diesen Berechtigungen:

```
Repository permissions:
  Issues: Read
  Pull requests: Read
  Contents: Read
  Metadata: Read

Organization permissions:
  Members: Read

Subscribe to events:
  Issues
  Pull request
  Push
  Release
  Star
  Fork
```

### Option 2: Fine-Grained Personal Access Token

1. Gehe zu **Settings** > **Developer settings** > **Personal access tokens** > **Fine-grained tokens**
2. Klicke auf **Generate new token**
3. Wähle die Ziel-Repositories aus
4. Gewähre diese Berechtigungen:

```
Repository access: Selected repositories
Permissions:
  Issues: Read-only
  Pull requests: Read-only
  Contents: Read-only
  Metadata: Read-only
```

Token-Sicherheit

Fine-Grained-Tokens haben Ablaufdaten. Richte eine Token-Rotation vor Ablauf ein. GitHub-App-Installationstokens werden automatisch erneuert und sind für den produktiven Einsatz zu bevorzugen.

### Verbindung zu Tajo herstellen

```bash
# Using GitHub App
tajo connectors install github \
  --app-id $GITHUB_APP_ID \
  --private-key-path ./github-app-key.pem \
  --installation-id $GITHUB_INSTALLATION_ID

# Using Personal Access Token
tajo connectors install github \
  --token $GITHUB_TOKEN
```

## Konfiguration

### Grundeinrichtung

```yaml
connectors:
  github:
    enabled: true
    auth_type: "github_app"  # or "token"

    repositories:
      - owner/repo-1
      - owner/repo-2

    sync:
      issues: true
      pull_requests: true
      releases: true
      contributors: true
      stars: true

    lists:
      contributors: 20
      stargazers: 21
```

### Feldzuordnung

Ordne GitHub-Nutzer:innen-Daten Brevo-Kontaktattributen zu:

```yaml
field_mapping:
  # Standard fields
  login: GITHUB_USERNAME
  email: email
  name: FIRSTNAME

  # Developer metrics
  contributions: GITHUB_CONTRIBUTIONS
  repositories_count: GITHUB_REPOS
  followers: GITHUB_FOLLOWERS
  created_at: GITHUB_JOINED

  # Custom attributes
  company: COMPANY
  location: LOCATION
  bio: GITHUB_BIO
```

## API-Endpunkte

Tajo integriert die folgenden Endpunkte der GitHub REST API:

| Endpunkt | Methode | Zweck |
| --- | --- | --- |
| `/repos/{owner}/{repo}/issues` | GET | Repository-Issues auflisten |
| `/repos/{owner}/{repo}/pulls` | GET | Pull Requests auflisten |
| `/repos/{owner}/{repo}/releases` | GET | Releases auflisten |
| `/repos/{owner}/{repo}/contributors` | GET | Contributor:innen auflisten |
| `/repos/{owner}/{repo}/stargazers` | GET | Stargazer auflisten |
| `/repos/{owner}/{repo}/forks` | GET | Forks auflisten |
| `/repos/{owner}/{repo}/events` | GET | Repository-Events auflisten |
| `/users/{username}` | GET | Nutzer:innen-Profil abrufen |
| `/orgs/{org}/members` | GET | Mitglieder der Organisation auflisten |
| `/repos/{owner}/{repo}/hooks` | POST | Webhook anlegen |

## Code-Beispiele

### Connector initialisieren

```javascript
import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('github', {
  appId: process.env.GITHUB_APP_ID,
  privateKey: process.env.GITHUB_PRIVATE_KEY,
  installationId: process.env.GITHUB_INSTALLATION_ID
});
```

### Contributor:innen mit Brevo synchronisieren

```javascript
await tajo.connectors.sync('github', {
  type: 'full',
  resources: ['contributors'],
  repositories: ['owner/repo-1', 'owner/repo-2']
});

const status = await tajo.connectors.status('github');
console.log(status);
// {
//   connected: true,
//   lastSync: '2024-03-15T11:00:00Z',
//   contributorsCount: 245,
//   issuesTracked: 1890,
//   releasesTracked: 34
// }
```

### Webhook-Events verarbeiten

```javascript
app.post('/webhooks/github', async (req, res) => {
  const signature = req.get('X-Hub-Signature-256');
  const event = req.get('X-GitHub-Event');

  // Verify webhook signature
  if (!verifyGitHubSignature(req.body, signature)) {
    return res.status(401).send('Unauthorized');
  }

  await tajo.connectors.handleWebhook('github', {
    event,
    payload: req.body
  });

  res.status(200).send('OK');
});
```

### Release-Kampagne auslösen

```javascript
// Listen for new releases and trigger Brevo campaign
tajo.connectors.on('github', 'release.published', async (event) => {
  await tajo.campaigns.trigger('release-announcement', {
    listId: 21,
    params: {
      version: event.release.tag_name,
      release_notes: event.release.body,
      download_url: event.release.html_url
    }
  });
});
```

## Ratenbegrenzungen

GitHub erzwingt Ratenbegrenzungen je nach Authentifizierungsmethode:

| Authentifizierung | Primäres Rate-Limit | Search API |
| --- | --- | --- |
| **Nicht authentifiziert** | 60 Anfragen/Stunde | 10 Anfragen/Minute |
| **Personal Access Token** | 5.000 Anfragen/Stunde | 30 Anfragen/Minute |
| **GitHub App (Installation)** | 5.000 Anfragen/Stunde | 30 Anfragen/Minute |
| **GitHub App (User-to-Server)** | 5.000 Anfragen/Stunde | 30 Anfragen/Minute |

Conditional Requests

Tajo verwendet Conditional Requests (`If-None-Match`/`If-Modified-Since`-Header), um den API-Verbrauch zu reduzieren. Antworten mit `304 Not Modified` werden nicht auf das Rate-Limit angerechnet.

Weitere Begrenzungen:

- **Sekundäre Ratenbegrenzungen**: Maximal 100 gleichzeitige Anfragen. Maximal 900 Punkte pro Minute für REST-API-Endpunkte.
- **GraphQL**: 5.000 Punkte pro Stunde (Abfragekosten variieren je nach Komplexität).

## Fehlerbehebung

### Häufige Probleme

| Problem | Ursache | Lösung |
| --- | --- | --- |
| 401 Unauthorized | Abgelaufenes Token oder falsche Zugangsdaten | Token erneuern oder GitHub-App neu installieren |
| 403 Forbidden | Unzureichende Berechtigungen | Token-Scopes oder App-Berechtigungen prüfen |
| 404 Not Found | Privates Repo ohne Zugriff | Repository-Zugriff dem Token oder der App erteilen |
| Rate Limit überschritten | Zu viele API-Aufrufe | Conditional Requests aktivieren und Synchronisationsfrequenz reduzieren |
| Webhooks werden nicht empfangen | Falsche URL oder Firewall | Prüfe, ob die Webhook-URL öffentlich erreichbar ist |

### Debug-Modus

```yaml
connectors:
  github:
    debug: true
    log_level: verbose
    log_webhooks: true
```

### Verbindung testen

```bash
tajo connectors test github
# ✓ API authentication successful
# ✓ Repository access verified
# ✓ Issue data readable
# ✓ Webhook delivery active
# ✓ Rate limit healthy (4,850/5,000 remaining)
```

## Best Practices

1. **GitHub Apps statt PATs verwenden** - GitHub Apps bieten granulare Berechtigungen und automatisch erneuerte Tokens
2. **Webhook-Secrets aktivieren** - Verifiziere Webhook-Signaturen stets mit HMAC-SHA256
3. **Conditional Requests nutzen** - Verwende ETags, um Rate-Limit-Kontingente zu schonen
4. **Große Antworten paginieren** - GitHub liefert maximal 100 Einträge pro Seite; iteriere über `Link`-Header
5. **Vollständige Syncs zu Niedriglastzeiten planen** - Führe Full-Syncs außerhalb der Hauptentwicklungszeiten aus
6. **Rate-Limit-Header überwachen** - Prüfe `X-RateLimit-Remaining`, um proaktiv zu drosseln

## Sicherheit

- **GitHub-App-Authentifizierung** - RSA-Key-basierte JWTs mit kurzlebigen Installationstokens
- **Webhook-Signaturen** - HMAC-SHA256-Signaturprüfung für alle Webhook-Payloads
- **Fine-Grained Tokens** - Auf bestimmte Repositories und Berechtigungen beschränkt
- **Nur HTTPS** - Die gesamte API-Kommunikation ist per TLS 1.2+ verschlüsselt
- **Verschlüsselte Speicherung** - Private Keys und Tokens werden in Tajo verschlüsselt gespeichert
- **Token-Ablauf** - Fine-Grained-Tokens laufen automatisch ab; richte Rotationsalarme ein

## Verwandte Ressourcen

- [Jira Connector](https://tajo.io/de/docs/connectors/custom/jira)
- [Linear Connector](https://tajo.io/de/docs/connectors/custom/linear)
- [Notion Connector](https://tajo.io/de/docs/connectors/custom/notion)
- [Brevo Contacts API](https://tajo.io/de/docs/contact-management)