Erstellen eines Remote-Git-Hubs für Ihr Unternehmen (ohne Github)

Erstellen eines Remote-Git-Hubs für Ihr Unternehmen: Ein umfassender Leitfaden

In diesem Artikel erfahren Sie, wie Sie einen Remote-Git-Hub für Ihr Unternehmen erstellen, ohne auf GitHub angewiesen zu sein. Wir verwenden TypeScript und Go für die Backend-Implementierung, integrieren MySQL für die Datenspeicherung und implementieren die Benutzerauthentifizierung mithilfe von FIDO2. Diese Lösung bietet eine sichere und anpassbare Alternative zu Hosting-Plattformen von Drittanbietern.

Backend-Implementierung

TypeScript-Server

Beginnen wir mit der Einrichtung des TypeScript-Servers für die Verarbeitung von Git-Operationen:

import express from 'express';
import { execSync } from 'child_process';

const app = express();
const port = 3000;

app.post('/create-repo', (req, res) => {
  const { repoName } = req.body;
  try {
    execSync(`git init --bare /path/to/repos/${repoName}.git`);
    res.status(200).json({ message: 'Repository created successfully' });
  } catch (error) {
    res.status(500).json({ error: 'Failed to create repository' });
  }
});

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

Dieser TypeScript-Server bietet einen Endpunkt zum Erstellen neuer Git-Repositorys auf dem Server.

Gehen Sie zum Git-Server

Als nächstes implementieren wir einen Go-Server zur Abwicklung von Git-Push- und Pull-Vorgängen:

package main

import (
    "fmt"
    "net/http"
    "os/exec"
)

func handleGitOperation(w http.ResponseWriter, r *http.Request) {
    repoPath := r.URL.Path[1:]
    gitCommand := r.Header.Get("X-Git-Command")

    cmd := exec.Command("git", gitCommand, "--stateless-rpc", repoPath)
    cmd.Stdin = r.Body
    cmd.Stdout = w
    cmd.Stderr = w

    if err := cmd.Run(); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
}

func main() {
    http.HandleFunc("/", handleGitOperation)
    fmt.Println("Git server running on :8080")
    http.ListenAndServe(":8080", nil)
}

Dieser Go-Server verarbeitet Git-Push- und Pull-Vorgänge, indem er die entsprechenden Git-Befehle ausführt.

Datenbankintegration

Um Repository-Metadaten und Benutzerinformationen zu speichern, verwenden wir MySQL. Hier ist ein Beispiel, wie Sie die Datenbankverbindung einrichten und Tabellen erstellen:

import mysql from 'mysql2/promise';

const pool = mysql.createPool({
  host: 'localhost',
  user: 'your_username',
  password: 'your_password',
  database: 'git_hub',
});

async function createTables() {
  const connection = await pool.getConnection();
  try {
    await connection.query(`
      CREATE TABLE IF NOT EXISTS repositories (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(255) NOT NULL,
        owner_id INT NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      )
    `);
    await connection.query(`
      CREATE TABLE IF NOT EXISTS users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        username VARCHAR(255) NOT NULL,
        email VARCHAR(255) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      )
    `);
  } finally {
    connection.release();
  }
}

createTables();

Dieser Code richtet die MySQL-Verbindung ein und erstellt Tabellen zum Speichern von Repository- und Benutzerinformationen.

Benutzerauthentifizierung mit FIDO2

Die Implementierung der FIDO2-Authentifizierung bietet ein sicheres, passwortloses Anmeldeerlebnis. Hier ist ein einfaches Beispiel für die Integration der FIDO2-Authentifizierung:

import { Fido2Lib } from 'fido2-lib';

const f2l = new Fido2Lib({
  timeout: 60000,
  rpId: 'your-company.com',
  rpName: 'Your Company Git Hub',
  challengeSize: 128,
  attestation: 'none',
  cryptoParams: [-7, -257],
});

app.post('/register', async (req, res) => {
  const { username, email } = req.body;
  const challengeResponse = await f2l.attestationOptions();
  // Store challenge and user info in the database
  res.json(challengeResponse);
});

app.post('/login', async (req, res) => {
  const { credential } = req.body;
  try {
    const result = await f2l.assertionResult(credential, {
      challenge: 'stored_challenge',
      origin: 'https://your-company.com',
      factor: 'either',
    });
    // Verify the result and create a session
    res.json({ success: true });
  } catch (error) {
    res.status(401).json({ error: 'Authentication failed' });
  }
});

Dieser Code stellt grundlegende Endpunkte für die FIDO2-Registrierung und -Anmeldung bereit. Sie müssen zusätzliche Logik implementieren, um Herausforderungen und Benutzeranmeldeinformationen in der Datenbank zu speichern und abzurufen.

Abschluss

Durch die Kombination von TypeScript und Go für das Backend, MySQL für die Datenspeicherung und FIDO2 für die Benutzerauthentifizierung können Sie einen robusten und sicheren Remote-Git-Hub für Ihr Unternehmen erstellen. Diese Lösung bietet vollständige Kontrolle über Ihren Quellcode und die Benutzerverwaltung, ohne auf Plattformen von Drittanbietern wie GitHub angewiesen zu sein.

Denken Sie daran, in einer Produktionsumgebung ordnungsgemäße Fehlerbehandlungs-, Protokollierungs- und Sicherheitsmaßnahmen zu implementieren. Erwägen Sie außerdem das Hinzufügen von Funktionen wie Zugriffskontrolle, Codeüberprüfungsprozessen und Integration mit Ihren vorhandenen Entwicklungstools, um eine umfassende Git-Verwaltungslösung zu erstellen, die auf die Anforderungen Ihres Unternehmens zugeschnitten ist.

Das obige ist der detaillierte Inhalt vonErstellen eines Remote-Git-Hubs für Ihr Unternehmen (ohne Github). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!