Golang implementiert Protokollprüfung

Mit der kontinuierlichen Geschäftsentwicklung nimmt auch die Bedeutung von Systemprotokollen und Prüfprotokollen zu. Die langfristige Weiterentwicklung des Protokollierungssystems erfordert eine effiziente und zuverlässige Technologie sowie ausreichende Flexibilität und Skalierbarkeit. In den letzten Jahren hat Golang als effiziente Programmiersprache auch einzigartige Vorteile bei der Protokollprüfung gezeigt. In diesem Artikel wird vorgestellt, wie Golang die Protokollprüfung implementiert.

1. Vorteile von Golang bei der Protokollprüfung

1. Coroutine

golang hat die Eigenschaften von Coroutine (Goroutine) und kann problemlos eine große Anzahl gleichzeitiger Ausführungsprogramme erstellen, wodurch die Sicherheit von Daten bei hohem gleichzeitigem Datenverkehr gewährleistet werden kann Integrität vermeidet verschiedene umständliche und gefährliche Faktoren beim Multithreading.

2. Garbage-Collection-Mechanismus

golang verfügt über einen eigenen Garbage-Collection-Mechanismus, der den Speicher automatisch verwalten kann. Dieser Mechanismus löst nicht nur das Problem von Speicherlecks, sondern reduziert auch die Speicherverwaltung und -verarbeitung des Programmierers und verbessert so die Effizienz der Programmierung.

3. Plattformübergreifend

Golang-Code kann plattformübergreifend kompiliert werden, was sehr praktisch ist. Gleichzeitig unterstützt Golang auch eine Vielzahl von Betriebssystemen, einschließlich Mainstream-Betriebssystemen wie Windows, Linux, macOS usw., die den Anforderungen verschiedener Plattformen gerecht werden können.

4. Leistungsoptimierung

Golangs Leistung ist sehr gut, seine Geschwindigkeit und Ausführungseffizienz sind höher als bei anderen Sprachen. Dies bedeutet, dass die Systemleistung sichergestellt werden kann, ohne die Systemleistung bei hoher Parallelität zu beeinträchtigen, die Reaktionsgeschwindigkeit der Schnittstelle sicherzustellen und die Systemverfügbarkeit und -stabilität zu verbessern.

2. Spezifische Methoden zur Implementierung der Protokollprüfung in Golang

1. Beim Design des Protokollsystems muss Golang im Allgemeinen die folgenden Aspekte berücksichtigen:

• Datenbankbetrieb: Durch die Verwendung des ORM-Frameworks von Golang können wir die Datenbank einfach betreiben und Daten speichern und lesen.
• Authentifizierung: Im Protokollüberwachungssystem ist eine Authentifizierung erforderlich, um bestimmte Vorgänge zu überwachen.
• Protokollabfrage: Für die Abfrageanforderungen des Protokollsystems muss überlegt werden, wie angemessene Abfragebedingungen und Abfragemethoden entworfen werden.
• Protokollspeicherung: Sie müssen eine geeignete Speichermethode auswählen, um die Integrität und Sicherheit der Protokolldaten zu gewährleisten.
• 2. Verwenden Sie die Logrus-Bibliothek, um die Protokollierung zu implementieren.

In Golang ist Logrus ein sehr beliebtes Protokollierungsframework, das mehrere Protokollausgabemethoden unterstützt und eine umfangreiche API-Schnittstelle bietet. Einfach ausgedrückt ist Logrus eine Protokollierungsbibliothek, die hochgradig anpassbare Protokollierungslösungen bereitstellen kann.

LOGRUS unterstützt die folgenden Ebenen der Protokollausgabe:

• debug
• info
• warn
• Error
• fatal
• panic
• using Logrus kann beispielsweise die Protokollaufzeichnung, -ausgabe und -verwaltung problemlos erreichen können wir das Ausgabeformat, die Ausgabeebene, die Ausgabe in eine Datei, die Ausgabe auf einen anderen Computer usw. anpassen. Diese Flexibilität macht Golang zur idealen Wahl für die Protokollprüfung.

3. Implementieren Sie das Audit-Log-System.

Lassen Sie uns ein einfaches Audit-Log-System implementieren. Dieses System kann Benutzerbetriebsprotokolle aufzeichnen und in der Datenbank speichern, was es Administratoren erleichtert, Audits durchzuführen.

Um die Golang-Webservice-Umgebung aufzubauen, können wir zunächst die Drittanbieter-Bibliothek Gorilla/Mux verwenden, um das Routing zu verwalten. Nach der Implementierung des Routings müssen wir für jede Schnittstelle unterschiedliche Handlerfunktionen definieren, z. B. Anmeldung, Abmeldung, Abfrage usw.

Nach der Verarbeitung jeder Schnittstelle implementieren wir die Aufzeichnung des Prüfprotokolls. Wir können die Logrus-Bibliothek zum Aufzeichnen von Protokollen verwenden. Definieren Sie zunächst einen Protokollprozessor, der Protokolle an die Konsole oder andere externe Dateien ausgeben kann.

logrus.SetLevel(logrus.TraceLevel)

Dann müssen wir während des Verarbeitungsprozesses der Schnittstelle die Vorgänge jedes Benutzers aufzeichnen. Sie können Benutzervorgänge aufzeichnen, indem Sie eine Protokollformatvorlage und ein Protokollobjekt definieren. Wenn wir das Protokoll definieren, zeichnen wir den Benutzernamen und die IP-Adresse der Benutzeranmeldung sowie die aufgerufene Schnittstelle und die Anforderungsmethode auf. Dies macht es sehr komfortabel, Audit-Protokolle aufzuzeichnen.

Protokollobjektdefinition:

Typ AuditLog-Struktur {

ID uint64
Username string
IPAddress string
Method string
Path string
CreatedAt time.Time

}

Protokollformat:

func (auditLog *AuditLog) String() string {

// format the log into json format
buf := bytes.NewBuffer(nil)

// begin log format
buf.WriteString("{")
buf.WriteString(fmt.Sprintf(""id":"%d",", auditLog.ID))
buf.WriteString(fmt.Sprintf(""username":"%s",", auditLog.Username))
buf.WriteString(fmt.Sprintf(""ip_address":"%s",", auditLog.IPAddress))
buf.WriteString(fmt.Sprintf(""method":"%s",", auditLog.Method))
buf.WriteString(fmt.Sprintf(""path":"%s",", auditLog.Path))
buf.WriteString(fmt.Sprintf(""created_at":%d", auditLog.CreatedAt.Unix()))
// end log format
buf.WriteString("}")

return buf.String()

}

Aufzeichnungsprotokoll:

func. AuditingLogM Middleware( weiter http.Handler) http.Handler {

return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()

    var username string
    var ok bool

    // 根据实际场景修改，这里以token作为身份认证方式
    if token := r.Header.Get("Authorization"); token != "" {
        tokenParts := strings.Split(token, " ")

        if len(tokenParts) == 2 {
            tokenType := tokenParts[0]
            tokenContent := tokenParts[1]

            // 根据实际场景修改，这里假设发放的Token为JWT
            if tokenType == "Bearer" {
                claims, err := util.ParseJwtToken(util.JwtKey, tokenContent)
                if err == nil {
                    username, ok = claims["username"].(string)
                }
            }
        }
    }

    // 添加审计日志
    auditLog := &AuditLog{
        Username:  username, // 登录的用户名
        IPAddress: r.RemoteAddr, // 客户端IP地址
        Method:    r.Method, // http请求类型（GET、POST、PUT、DELETE……）
        Path:      r.URL.Path, // 请求的URL路径
        CreatedAt: time.Now(), // 日志创建时间
    }

    logrus.Trace(auditLog)

    // Call the next handler, which can be another middleware in the chain, or the final handler.
    next.ServeHTTP(w, r)

    // 审计log耗时
    end := time.Now()

    diff := end.Sub(start)
    logrus.Tracef("log time to response: %dms", int64(diff/time.Millisecond))
})

}

Nachdem wir das Protokoll aufgezeichnet haben, müssen wir das Protokoll in die Datenbank schreiben. Hier gehen wir davon aus, dass Gorm als ORM-Framework zum Betrieb der Datenbank verwendet wird.

GORM ist eine leichte ORM-Bibliothek für SQL-Datenbanken, die MySQL, PostgreSQL, Sqlite3 und andere Datenbanken unterstützt.

func DatabaseUri(Benutzer, Passwort, Datenbank, Host, Portzeichenfolge) Zeichenfolge {

return fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, host, port, database)

}

func SetupDB()-Fehler {

var err error

dbUri := DatabaseUri("root", "", "log_audit", "localhost", "3306")
db, err = gorm.Open(mysql.Open(dbUri), &gorm.Config{
    Logger: &logger.Default{},
})

if err != nil {
    panic("failed to connect database")
}

// 定义migration 操作等

return nil

}

Denken Sie daran, SetupDB zuerst in der Hauptfunktion aufzurufen, da es die Datenbank betreibt Bei der Initialisierungsfunktion müssen Sie sicherstellen, dass Sie eine Verbindung zur Datenbank herstellen, bevor Sie sie bearbeiten.

Die Funktion, die AuditLogMiddleware aufruft, muss in der Serviceroute registriert werden. Es wird davon ausgegangen, dass die Geschäftsanforderungen synchron in zuverlässige Nachrichtenwarteschlangen wie Kafka, Nats, NSQ usw. geschrieben werden müssen. für die anschließende asynchrone Verarbeitung.

Zu diesem Zeitpunkt ist die Implementierung der Protokollprüfung in Golang abgeschlossen. Durch die oben genannten Methoden können wir ein effizientes und zuverlässiges Protokollierungssystem und Prüfmodul in Golang implementieren, wodurch eine solide Grundlage für unsere Geschäftsentwicklung gelegt und die Zuverlässigkeit und Sicherheit des Systems besser gewährleistet wird.

Das obige ist der detaillierte Inhalt vonGolang implementiert Protokollprüfung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!