Golang implémente l'audit des journaux

Avec le développement continu des affaires, l'importance des journaux système et des journaux d'audit augmente également. Le développement à long terme du système de journalisation nécessite une technologie efficace et fiable, ainsi qu'une flexibilité et une évolutivité suffisantes. Ces dernières années, Golang, en tant que langage de programmation efficace, a également montré des avantages uniques en matière d'audit des journaux. Cet article présentera comment Golang implémente l'audit des journaux.

1. Avantages de Golang dans l'audit des journaux

1. Coroutine

golang a les caractéristiques de la coroutine (goroutine) et peut facilement créer un grand nombre de programmes d'exécution simultanés, ce qui lui permet de garantir la sécurité des données et un trafic simultané élevé. L'intégrité évite divers facteurs encombrants et dangereux en multi-threading.

2. Mécanisme de collecte des ordures

golang possède son propre mécanisme de collecte des ordures qui peut gérer automatiquement la mémoire. Ce mécanisme résout non seulement le problème des fuites de mémoire, mais réduit également la gestion et le traitement de la mémoire du programmeur, améliorant ainsi l'efficacité de la programmation.

3. Le code golang multiplateforme peut être compilé sur plusieurs plateformes, ce qui est très pratique. Dans le même temps, Golang prend également en charge une variété de systèmes d'exploitation, y compris les systèmes d'exploitation grand public tels que Windows, Linux, macOS, etc., qui peuvent répondre aux besoins de différentes plates-formes.

4. Optimisation des performances

Les performances de Golang sont très bonnes, sa vitesse et son efficacité d'exécution sont supérieures à celles des autres langages. Cela signifie que les performances du système peuvent être garanties sans réduire les performances du système dans des conditions de concurrence élevée, en garantissant la vitesse de réponse de l'interface et en améliorant la disponibilité et la stabilité du système.

2. Méthodes spécifiques de mise en œuvre de l'audit des journaux dans Golang

1. Conception du système de journalisation

Golang doit généralement prendre en compte les aspects suivants pour mettre en œuvre l'audit des journaux :

Formatage des enregistrements de journal : le système de journalisation doit être capable de analyser les enregistrements du journal et les formater selon Convertir et les stocker dans le format spécifié.

• Opération de base de données : en utilisant le framework ORM de golang, nous pouvons facilement exploiter la base de données et stocker et lire les données.
• Authentification : Dans le système d'audit des journaux, une authentification est requise pour auditer certaines opérations.
• Requête de journal : pour les exigences de requête du système de journalisation, il est nécessaire de réfléchir à la manière de concevoir des conditions et des méthodes de requête raisonnables.
• Stockage des journaux : vous devez choisir une méthode de stockage appropriée pour garantir l'intégrité et la sécurité des données des journaux.
• 2. Utilisez la bibliothèque logrus pour implémenter la journalisation

Dans Golang, logrus est un framework de journalisation très populaire qui prend en charge plusieurs méthodes de sortie de journal et fournit une interface API riche. En termes simples, logrus est une bibliothèque de journalisation qui peut fournir des solutions de journalisation hautement personnalisables.

Logrus prend en charge les niveaux suivants de sortie du journal:

Trace

• debug
• info
• warn
• error
• fatal
• panic
• using Logrus peut facilement atteindre l'enregistrement du journal, la sortie et la gestion, par exemple , nous pouvons personnaliser le format de sortie, le niveau de sortie, la sortie vers un fichier, la sortie vers une autre machine, etc. Cette flexibilité fait de Golang un choix idéal pour l'audit des journaux.

3. Implémenter le système de journal d'audit

Implémentons un système de journal d'audit simple. Ce système peut enregistrer les journaux d'opérations des utilisateurs et les stocker dans la base de données, ce qui facilite la réalisation des audits par les administrateurs.

Tout d'abord, pour créer l'environnement de service Web Golang, nous pouvons utiliser la bibliothèque tierce gorilla/mux pour gérer le routage. Après avoir implémenté le routage, nous devons définir différentes fonctions de gestionnaire pour chaque interface, telles que la connexion, la déconnexion, la requête, etc.

Après avoir traité chaque interface, implémentons l'enregistrement du journal d'audit. Nous pouvons utiliser la bibliothèque logrus pour enregistrer les journaux. Définissez d'abord un processeur de journaux, qui peut générer des journaux sur la console ou d'autres fichiers externes.

logrus.SetLevel(logrus.TraceLevel)

logrus.SetOutput(os.Stdout)

Ensuite, pendant le processus de traitement de l'interface, nous devons enregistrer les opérations de chaque utilisateur. Comment devons-nous les enregistrer spécifiquement ? Vous pouvez enregistrer les opérations utilisateur en définissant un modèle de format de journal et un objet de journal. Lorsque nous définissons le journal, nous enregistrerons le nom d'utilisateur et l'adresse IP de la connexion de l'utilisateur, ainsi que l'interface consultée et la méthode de demande. Cela rend très pratique l’enregistrement des journaux d’audit.

Définition de l'objet Log :

type AuditLog struct {

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

}

Format du journal :

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()

}

Enregistrer le journal d'audit :

func AuditingLogMiddleware( next 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))
})

}

Après avoir enregistré le journal, nous devons écrire le journal dans la base de données. Ici, nous supposons que gorm est utilisé comme framework ORM pour faire fonctionner la base de données.

GORM est une bibliothèque ORM légère pour les bases de données SQL, prenant en charge MySQL, PostgreSQL, Sqlite3 et d'autres bases de données.

func DatabaseUri (utilisateur, mot de passe, base de données, hôte, chaîne de port) chaîne {

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

}

func SetupDB() erreur {

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

}

N'oubliez pas d'appeler SetupDB d'abord dans la fonction principale car elle exploite la base de données Fonction d'initialisation, vous devez vous assurer de vous connecter à la base de données avant d'opérer dessus.

La fonction qui appelle AuditLogMiddleware doit être enregistrée dans la route du service. Elle répond à différentes exigences d'audit selon les besoins. Il est jugé que les besoins de l'entreprise doivent être écrits de manière synchrone dans des files d'attente de messages fiables telles que kafka, nats, nsq, etc. pour un traitement asynchrone ultérieur.

À ce stade, la mise en œuvre de l'audit des journaux dans Golang est terminée. Grâce aux méthodes ci-dessus, nous pouvons mettre en œuvre un système de journalisation et un module d'audit efficaces et fiables dans Golang, établissant ainsi une base solide pour notre développement commercial et garantissant mieux la fiabilité et la sécurité du système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!