DokumentePreiseBlog
Kontaktieren Sie uns
AnmeldenKOSTENLOS anmelden
Back to Tech Articles

Gopsutil: Effiziente Systemüberwachung in Go

März 17, 2025
# golang

Grace Collins

Solutions Engineer · Leapcell

Dieser Beitrag ist auch in English, 日本語 und 한국어 verfügbar
Cover of "Gopsutil: Effiziente Systemüberwachung in Go"

Einführung

gopsutil ist eine Golang-Portierung der Python-Bibliothek psutil, die uns hilft, bequem verschiedene System- und Hardwareinformationen zu erhalten. Sie maskiert die Unterschiede zwischen verschiedenen Systemen und verfügt über eine extrem hohe Portabilität. Mit gopsutil müssen wir nicht syscall verwenden, um die entsprechenden Systemmethoden für verschiedene Systeme aufzurufen. Was noch besser ist, ist, dass die Implementierung von gopsutil keinen cgo-Code enthält, was die Cross-Kompilierung ermöglicht.

Schnellstart

Installation

Führen Sie den folgenden Befehl aus, um zu installieren:

$ go get github.com/shirou/gopsutil

Anwendungsbeispiel

package main

import (
    "fmt"
    "github.com/shirou/gopsutil/mem"
)

func main() {
    v, _ := mem.VirtualMemory()
    fmt.Printf("Total: %v, Available: %v, UsedPercent:%f%%\n", v.Total, v.Available, v.UsedPercent)
    fmt.Println(v)
}

gopsutil unterteilt verschiedene Funktionen in verschiedene Unterpakete:

  • cpu: Bezogen auf die CPU;
  • disk: Bezogen auf die Festplatte;
  • docker: Bezogen auf Docker;
  • host: Bezogen auf den Host;
  • mem: Bezogen auf den Speicher;
  • net: Bezogen auf das Netzwerk;
  • process: Bezogen auf den Prozess;
  • macservices: Bezogen auf Mac-Dienste (das ursprüngliche winservices entspricht Windows-Diensten, was hier für das Mac-System geändert wurde).

Um die entsprechenden Funktionen zu verwenden, müssen Sie die entsprechenden Unterpakete importieren. Um beispielsweise im obigen Code Speicherinformationen zu erhalten, wird das Unterpaket mem importiert. Die Methode mem.VirtualMemory() gibt die Speicherinformationsstruktur mem.VirtualMemoryStat zurück, die umfangreiche Felder enthält. Die wichtigsten, die wir üblicherweise verwenden, sind Total (Gesamtspeicher), Available (verfügbarer Speicher), Used (verwendeter Speicher) und UsedPercent (Speicherbelegung in Prozent). mem.VirtualMemoryStat implementiert auch die Schnittstelle fmt.Stringer und gibt die Speicherinformationen im JSON-Format zurück. Die Anweisung fmt.Println(v) ruft automatisch v.String() auf, um die zurückgegebenen Informationen auszugeben. Angenommen, das Programm gibt Folgendes aus (die Daten hier sind ein vernünftiger angenommener Wert):

Total: 16441110528, Available: 8589934592, UsedPercent:47.730000%
{"total":16441110528,"available":8589934592,"used":7851175936,"usedPercent":47.730000,"free":7959955456,"active":8220555264,"inactive":6815744000,"wired":1429770240,"laundry":0,"buffers":0,"cached":0,"writeback":0,"dirty":0,"writebacktmp":0,"shared":0,"slab":0,"sreclaimable":0,"sunreclaim":0,"pagetables":0,"swapcached":0,"commitlimit":0,"committedas":0,"hightotal":0,"highfree":0,"lowtotal":0,"lowfree":0,"swaptotal":0,"swapfree":0,"mapped":0,"vmalloctotal":0,"vmallocused":0,"vmallocchunk":0,"hugepagestotal":0,"hugepagesfree":0,"hugepagesize":0}

Die Einheit ist Byte. Angenommen, der Computerspeicher beträgt 16 GB, die aktuelle Auslastung beträgt 47,73 % und der verfügbare Speicher beträgt 8589934592 B (d. h. 8 GB).

CPU

Die Anzahl der CPU-Kerne wird in die Anzahl der physischen Kerne und die Anzahl der logischen Kerne unterteilt. Die Anzahl der physischen Kerne ist die tatsächliche Anzahl der CPUs auf dem Motherboard. Es kann mehrere Kerne auf einer physischen CPU geben, und diese Kerne werden als logische Kerne bezeichnet. Die Funktionen, die sich auf die CPU beziehen, befinden sich im Unterpaket cpu. Dieses Unterpaket bietet Schnittstellen zum Abrufen der Anzahl physischer und logischer Kerne sowie der CPU-Auslastung:

  • Counts(logical bool): Übergibt false, um die Anzahl der physischen Kerne zurückzugeben; übergibt true, um die Anzahl der logischen Kerne zurückzugeben;
  • Percent(interval time.Duration, percpu bool): Wird verwendet, um die CPU-Auslastung innerhalb des Zeitintervalls interval abzurufen. Wenn percpu false ist, wird die gesamte CPU-Auslastung abgerufen; wenn percpu true ist, wird die Auslastung jeder CPU einzeln abgerufen und ein Wert vom Typ []float64 zurückgegeben.

Zum Beispiel:

func main() {
    physicalCnt, _ := cpu.Counts(false)
    logicalCnt, _ := cpu.Counts(true)
    fmt.Printf("physical count:%d logical count:%d\n", physicalCnt, logicalCnt)

    totalPercent, _ := cpu.Percent(3*time.Second, false)
    perPercents, _ := cpu.Percent(3*time.Second, true)
    fmt.Printf("total percent:%v per percents:%v", totalPercent, perPercents)
}

Der obige Code ruft die Anzahl der physischen und logischen Kerne sowie die gesamte CPU-Auslastung und die Auslastung jeder CPU innerhalb von 3 Sekunden ab. Die Programmausgabe (die Ausgabe kann bei jeder Ausführung unterschiedlich sein, und die Werte hier werden angenommen):

physical count:12 logical count:12
total percent:[6.59835041239871] per percents:[15.77181208051725 14.04682274248692 11.03678929768094 7.692307692328751 3.6789297658885762 1.999999999998181 0.664451827243077 0 0 0 0 0]

Detaillierte Informationen

Durch Aufrufen von cpu.Info() können detaillierte Informationen über die CPU abgerufen und []cpu.InfoStat zurückgegeben werden:

func main() {
    infos, _ := cpu.Info()
    for _, info := range infos {
        data, _ := json.MarshalIndent(info, "", " ")
        fmt.Print(string(data))
    }
}

Um die Ansicht zu vereinfachen, werden die Ergebnisse im JSON-Format ausgegeben:

{
    "cpu": 0,
    "vendorId": "Apple",
    "family": "Apple Silicon",
    "model": "M1 Pro",
    "stepping": 0,
    "physicalId": "abcd1234",
    "coreId": "",
    "cores": 10,
    "modelName": "Apple M1 Pro",
    "mhz": 3200,
    "cacheSize": 32768,
    "flags": [],
    "microcode": ""
}

Aus den Ergebnissen können wir ersehen, dass die CPU aus Apples M1 Pro-Serie mit einer Frequenz von 3,2 GHz stammt. Dies ist das zurückgegebene Ergebnis bei der Ausführung auf einem Mac, und die Bibliothek github.com/StackExchange/wmi wird intern verwendet (vorausgesetzt, diese Bibliothek verfügt noch über relevante Funktionen im Mac-Szenario, und es muss möglicherweise angepasst werden). Unter Linux gibt jede logische CPU eine InfoStat-Struktur zurück.

Zeitauslastung

Durch Aufrufen von cpu.Times(percpu bool) kann die Zeitauslastung der gesamten CPU und jeder einzelnen CPU ab der Startzeit abgerufen werden. Übergeben Sie percpu = false, um den Gesamtwert zurückzugeben, und übergeben Sie percpu = true, um den Wert für jede einzelne CPU zurückzugeben. Die Zeitauslastung jeder CPU wird durch eine TimeStat-Struktur dargestellt:

// src/github.com/shirou/gopsutil/cpu/cpu.go
type TimesStat struct {
    CPU       string  `json:"cpu"`
    User      float64 `json:"user"`
    System    float64 `json:"system"`
    Idle      float64 `json:"idle"`
    Nice      float64 `json:"nice"`
    Iowait    float64 `json:"iowait"`
    Irq       float64 `json:"irq"`
    Softirq   float64 `json:"softirq"`
    Steal     float64 `json:"steal"`
    Guest     float64 `json:"guest"`
    GuestNice float64 `json:"guestNice"`
}
  • CPU: CPU- Kennung. Wenn es sich um den Gesamtwert handelt, ist dieses Feld cpu - total, andernfalls ist es cpu0, cpu1 usw.;
  • User: Benutzerzeitauslastung (Benutzermodus);
  • System: Systemzeitauslastung (Kernelmodus);
  • Idle: Leerlaufzeit;
  • ……

Zum Beispiel:

func main() {
    infos, _ := cpu.Times(true)
    for _, info := range infos {
        data, _ := json.MarshalIndent(info, "", " ")
        fmt.Print(string(data))
    }
}

Um die Ansicht zu vereinfachen, werden die Ergebnisse im JSON-Format ausgegeben. Das Folgende ist eine der Ausgaben (angenommener Wert):

{
    "cpu": "cpu0",
    "user": 123.45,
    "system": 234.56,
    "idle": 789.12,
    "nice": 0,
    "iowait": 0,
    "irq": 0,
    "softirq": 0,
    "steal": 0,
    "guest": 0,
    "guestNice": 0
}

Festplatte

Das Unterpaket disk wird verwendet, um Festplatteninformationen zu erhalten, und es kann IO-Statistiken, Partitionen und Nutzungsinformationen abrufen. Im Folgenden wird eine nach der anderen vorgestellt.

IO-Statistiken

Rufen Sie die Funktion disk.IOCounters() auf, und die zurückgegebenen IO-Statistikinformationen werden durch den Typ map[string]IOCountersStat dargestellt. Jede Partition entspricht einer Struktur, wobei der Schlüssel der Partitionsname und der Wert die statistischen Informationen sind. Hier werden einige Felder der statistischen Struktur ausgewählt, die hauptsächlich die Anzahl der Lese- und Schreibvorgänge, die Anzahl der Bytes und die Zeit umfassen:

// src/github.com/shirou/gopsutil/disk/disk.go
type IOCountersStat struct {
    ReadCount        uint64 `json:"readCount"`
    MergedReadCount  uint64 `json:"mergedReadCount"`
    WriteCount       uint64 `json:"writeCount"`
    MergedWriteCount uint64 `json:"mergedWriteCount"`
    ReadBytes        uint64 `json:"readBytes"`
    WriteBytes       uint64 `json:"writeBytes"`
    ReadTime         uint64 `json:"readTime"`
    WriteTime        uint64 `json:"writeTime"`
    // ……
}

Zum Beispiel:

func main() {
    mapStat, _ := disk.IOCounters()
    for name, stat := range mapStat {
        fmt.Println(name)
        data, _ := json.MarshalIndent(stat, "", "  ")
        fmt.Println(string(data))
    }
}

Die Ausgabe enthält alle Partitionen, und hier wird nur eine angezeigt (angenommener Wert):

disk0s2
{
  "readCount": 123456,
  "mergedReadCount": 0,
  "writeCount": 789012,
  "mergedWriteCount": 0,
  "readBytes": 5678901234,
  "writeBytes": 9876543210,
  "readTime": 200,
  "writeTime": 300,
  "iopsInProgress": 0,
  "ioTime": 0,
  "weightedIO": 0,
  "name": "disk0s2",
  "serialNumber": "1234567890ABCDEF",
  "label": "Macintosh HD"
}

Beachten Sie, dass disk.IOCounters() eine variable Anzahl von Zeichenfolgenparametern akzeptieren kann, um Partitionen zu identifizieren, und dieser Parameter ist auf dem Mac ungültig (die ursprüngliche Windows-bezogene Beschreibung wurde angepasst).

Partition

Rufen Sie die Funktion disk.PartitionStat(all bool) auf, um Partitionsinformationen zurückzugeben. Wenn all = false ist, werden nur die tatsächlichen physischen Partitionen (einschliesslich Festplatten, CD-ROMs, USBs) zurückgegeben, und andere virtuelle Partitionen werden ignoriert; wenn all = true ist, werden alle Partitionen zurückgegeben. Der Rückgabetyp ist []PartitionStat, und jede Partition entspricht einer PartitionStat-Struktur:

// src/github.com/shirou/gopsutil/disk/
type PartitionStat struct {
    Device     string `json:"device"`
    Mountpoint string `json:"mountpoint"`
    Fstype     string `json:"fstype"`
    Opts       string `json:"opts"`
}
  • Device: Partitionskennung. Auf dem Mac ist sie beispielsweise im Format disk0s2;
  • Mountpoint: Mountpoint, d. h. die Startposition des Dateipfads dieser Partition;
  • Fstype: Dateisystemtyp. Zu den häufig verwendeten Dateisystemtypen auf dem Mac gehören APFS usw.;
  • Opts: Optionen, die sich auf das System beziehen.

Zum Beispiel:

func main() {
    infos, _ := disk.Partitions(false)
    for _, info := range infos {
        data, _ := json.MarshalIndent(info, "", "  ")
        fmt.Println(string(data))
    }
}

Die Ausgabe auf einem Mac-Computer (es wird nur die erste Partition angezeigt, angenommener Wert):

{
    "device": "disk0s2",
    "mountpoint": "/",
    "fstype": "APFS",
    "opts": "rw"
}

Aus der obigen Ausgabe können wir ersehen, dass die erste Partition disk0s2 ist und der Dateisystemtyp APFS ist.

Nutzung

Durch Aufrufen von disk.Usage(path string) kann die Nutzung der Festplatte abgerufen werden, auf der sich der Pfad path befindet, und eine UsageStat-Struktur zurückgegeben werden:

// src/github.com/shirou/gopsutil/disk.go
type UsageStat struct {
    Path              string  `json:"path"`
    Fstype            string  `json:"fstype"`
    Total             uint64  `json:"total"`
    Free              uint64  `json:"free"`
    Used              uint64  `json:"used"`
    UsedPercent       float64 `json:"usedPercent"`
    InodesTotal       uint64  `json:"inodesTotal"`
    InodesUsed        uint64  `json:"inodesUsed"`
    InodesFree        uint64  `json:"inodesFree"`
    InodesUsedPercent float64 `json:"inodesUsedPercent"`
}
  • Path: Pfad, der übergebene Parameter;
  • Fstype: Dateisystemtyp;
  • Total: Gesamtkapazität dieser Partition;
  • Free: Freie Kapazität;
  • Used: Verwendete Kapazität;
  • UsedPercent: Nutzungsanteil.

Zum Beispiel:

func main() {
    info, _ := disk.Usage("/Users")
    data, _ := json.MarshalIndent(info, "", "  ")
    fmt.Println(string(data))
}

Da der zurückgegebene Wert die Nutzung der Festplatte ist, geben die Pfade /Users und der Stammpfad der Festplatte ähnliche Ergebnisse zurück, nur das Feld Path in der Struktur ist unterschiedlich. Die Programmausgabe (angenommener Wert):

{
    "path": "/Users",
    "fstype": "APFS",
    "total": 499999999999,
    "free": 300000000000,
    "used": 199999999999,
    "usedPercent": 39.99,
    "inodesTotal": 0,
    "inodesUsed": 0,
    "inodesFree": 0,
    "inodesUsedPercent": 0
}

Host

Das Unterpaket host kann Host-bezogene Informationen abrufen, wie z. B. Bootzeit, Kernel-Versionsnummer, Plattforminformationen usw.

Bootzeit

host.BootTime() gibt den Zeitstempel der Bootzeit des Hosts zurück:

func main() {
    timestamp, _ := host.BootTime()
    t := time.Unix(int64(timestamp), 0)
    fmt.Println(t.Local().Format("2006-01-02 15:04:05"))
}

Der obige Code ruft zuerst die Bootzeit ab, konvertiert sie dann mit time.Unix() in den Typ time.Time und gibt schliesslich die Zeit im Format 2006-01-02 15:04:05 aus (angenommener Wert):

2025-03-15 16:30:15

Kernel-Version und Plattforminformationen

func main() {
    version, _ := host.KernelVersion()
    fmt.Println(version)

    platform, family, version, _ := host.PlatformInformation()
    fmt.Println("platform:", platform)
    fmt.Println("family:", family)
    fmt.Println("version:", version)
}

Die Ausgabe bei der Ausführung auf einem Mac (angenommener Wert):

22.6.0
platform: macOS 13.5
family: Darwin
version: 22.6.0

## Terminalbenutzer
`host.Users()` gibt die Informationen von Benutzern zurück, die über das Terminal verbunden sind, und jeder Benutzer entspricht einer `UserStat`-Struktur:
```go
// src/github.com/shirou/gopsutil/host/host.go
type UserStat struct {
    User     string `json:"user"`
    Terminal string `json:"terminal"`
    Host     string `json:"host"`
    Started  int    `json:"started"`
}

Die Bedeutung der Felder ist klar. Hier ist ein Beispiel:

func main() {
    users, _ := host.Users()
    for _, user := range users {
        data, _ := json.MarshalIndent(user, "", " ")
        fmt.Println(string(data))
    }
}

Angenommen, das Folgende ist das Ausgaberesultat nach der Ausführung des obigen Codes (die tatsächlichen Werte variieren je nach Systemstatus und Benutzerverbindungssituation):

{
    "user": "leapcell",
    "terminal": "ttys001",
    "host": "localhost",
    "started": 565575675
}

Speicher

Im Schnellstartabschnitt haben wir gezeigt, wie mem.VirtualMemory() verwendet wird, um Speicherinformationen abzurufen, und diese Funktion gibt nur physische Speicherinformationen zurück. Wir können auch mem.SwapMemory() verwenden, um die Informationen des Swap-Speichers abzurufen, und die Informationen werden in der SwapMemoryStat-Struktur gespeichert:

// src/github.com/shirou/gopsutil/mem/
type SwapMemoryStat struct {
    Total       uint64  `json:"total"`
    Used        uint64  `json:"used"`
    Free        uint64  `json:"free"`
    UsedPercent float64 `json:"usedPercent"`
    Sin         uint64  `json:"sin"`
    Sout        uint64  `json:"sout"`
    PgIn        uint64  `json:"pgin"`
    PgOut       uint64  `json:"pgout"`
    PgFault     uint64  `json:"pgfault"`
}

Die Bedeutung dieser Felder ist relativ leicht zu verstehen. Unter diesen müssen die drei Felder PgIn, PgOut und PgFault hervorgehoben werden. Swap-Speicher ist in Seitengrössen angegeben. Wenn ein Seitenfehler auftritt, lädt das Betriebssystem einige Seiten von der Festplatte in den Speicher, und gleichzeitig werden einige Seiten im Speicher gemäss einem bestimmten Mechanismus eliminiert. PgIn stellt die Anzahl der geladenen Seiten dar, PgOut stellt die Anzahl der eliminierten Seiten dar und PgFault ist die Anzahl der Seitenfehler.

Zum Beispiel:

func main() {
    swapMemory, _ := mem.SwapMemory()
    data, _ := json.MarshalIndent(swapMemory, "", " ")
    fmt.Println(string(data))
}

Angenommen, das Folgende ist das Ausgaberesultat nach der Ausführung (die tatsächlichen Werte hängen von der Speichernutzung des Systems ab):

{
    "total": 8589934592,
    "used": 2147483648,
    "free": 6442450944,
    "usedPercent": 25.00,
    "sin": 1024,
    "sout": 512,
    "pgIn": 2048,
    "pgOut": 1536,
    "pgFault": 100
}

Prozess

process kann verwendet werden, um Informationen über die Prozesse abzurufen, die derzeit im System ausgeführt werden, neue Prozesse zu erstellen und einige Operationen an Prozessen durchzuführen usw.

func main() {
    var rootProcess *process.Process
    processes, _ := process.Processes()
    for _, p := range processes {
        if p.Pid == 0 {
            rootProcess = p
            break
        }
    }

    fmt.Println(rootProcess)

    fmt.Println("children:")
    children, _ := rootProcess.Children()
    for _, p := range children {
        fmt.Println(p)
    }
}

Der obige Code ruft zuerst process.Processes() auf, um alle im aktuellen System ausgeführten Prozesse abzurufen, sucht dann den Prozess mit Pid gleich 0 (auf einem Mac-System ist dieser Prozess normalerweise der erste vom Kernel gestartete Prozess) und ruft schliesslich Children() auf, um seine Child-Prozesse zurückzugeben. Darüber hinaus gibt es viele Methoden, mit denen Prozessinformationen abgerufen werden können, und interessierte Benutzer können sich in den dazugehörigen Dokumenten weiter informieren.

Mac-Dienste (angepasst aus dem ursprünglichen Abschnitt über Windows-Dienste)

Das Unterpaket macservices (das ursprüngliche winservices) kann Dienstinformationen im Mac-System abrufen (vorausgesetzt, ein solches Unterpaket und seine Funktionen existieren). In macservices entspricht ein Dienst einer Service-Struktur (die folgende Struktur wird angenommen und kann in der Realität unterschiedlich sein):

// src/github.com/shirou/gopsutil/macservices/macservices.go
type Service struct {
    Name   string
    Config MacConfig
    Status ServiceStatus
    // contains filtered or unexported fields
}

Unter diesen ist MacConfig (angepasst vom ursprünglichen mgr.Config für Mac) eine angenommene Struktur, und diese Struktur zeichnet detailliert Informationen wie den Diensttyp, den Starttyp (automatisch/manuell) und den binären Dateipfad auf (die angenommene Struktur ist wie folgt):

// src/github.com/shirou/gopsutil/macservices/macconfig.go
type MacConfig struct {
    ServiceType      string
    StartType        string
    BinaryPathName   string
    Dependencies     []string
    ServiceStartName string
    DisplayName      string
    Description      string
}

Die ServiceStatus-Struktur zeichnet den Status des Dienstes auf (die angenommene Struktur ist wie folgt):

// src/github.com/shirou/gopsutil/macservices/macservices.go
type ServiceStatus struct {
    State         string
    Pid           uint32
    ExitCode      int
}
  • State: Dienststatus, einschliesslich gestoppt, ausgeführt, pausiert usw.;
  • Pid: Prozess-ID;
  • ExitCode: Anwendungsexitstatuscode.

Das folgende Programm gibt die Namen, binären Dateipfade und Status aller Dienste im System auf der Konsole aus (der angenommene Code ist wie folgt):

func main() {
    services, _ := macservices.ListServices()

    for _, service := range services {
        newservice, _ := macservices.NewService(service.Name)
        newservice.GetServiceDetail()
        fmt.Println("Name:", newservice.Name, "Binary Path:", newservice.Config.BinaryPathName, "State: ", newservice.Status.State)
    }
}

Es sollte beachtet werden, dass die Informationen des Service-Objekts, das durch Aufrufen von macservices.ListServices() zurückgegeben wird, möglicherweise nicht vollständig sind. Wir erstellen einen Dienst mit dem Dienstnamen über NewService() und rufen dann die Methode GetServiceDetail() auf, um die detaillierten Informationen des Dienstes abzurufen. Wir können nicht direkt service.GetServiceDetail() aufrufen, da dem von ListService() zurückgegebenen Objekt möglicherweise die erforderlichen Systemressourcen-Handles fehlen (um Ressourcen zu sparen), und das Aufrufen der Methode GetServiceDetail() kann zu Programmfehlern führen.

Fehler und Timeouts

Da die meisten Funktionen zugrunde liegende Systemaufrufe beinhalten, sind Fehler und Timeouts unvermeidlich. Fast alle Schnittstellen haben zwei Rückgabewerte, und der zweite Rückgabewert wird verwendet, um einen Fehler anzuzeigen. In den vorherigen Beispielen haben wir, um den Code zu vereinfachen, die Fehlerbehandlung ignoriert. Bei der tatsächlichen Verwendung wird jedoch empfohlen, Fehler ordnungsgemäss zu behandeln.

Darüber hinaus gibt es die meisten Schnittstellen als Paare. Eine hat keinen Parameter vom Typ context.Context, und die andere hat diesen Parametertyp zur Kontextsteuerung. Sie kann Fehler oder Timeouts, die während interner Aufrufe auftreten, rechtzeitig behandeln und vermeiden, lange auf eine Rückgabe zu warten. Tatsächlich rufen Funktionen ohne context.Context-Parameter intern Funktionen mit einem context.Context-Parameter auf, indem sie context.Background() als Parameter verwenden. Zum Beispiel:

// src/github.com/shirou/gopsutil/cpu_mac.go
func Times(percpu bool) ([]TimesStat, error) {
    return TimesWithContext(context.Background(), percpu)
}

func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) {
    // ...
}

Fazit

Die gopsutil-Bibliothek bietet uns Komfort, um lokale Maschineninformationen abzurufen, und sie behandelt die Kompatibilitätsprobleme zwischen verschiedenen Systemen gut und bietet eine einheitliche Schnittstelle. Es gibt auch mehrere Unterpakete wie net und docker, die hier aus Platzgründen nicht vorgestellt werden. Interessierte Benutzer können sie самостоятельно в дальнейшем самостоятельно ausprobiert.

Leapcell: Die Serverless-Plattform der nächsten Generation für Webhosting, asynchrone Aufgaben und Redis

Abschliessend empfehle ich die am besten geeignete Golang-Bereitstellungsplattform: leapcell

pic

1. Mehrsprachige Unterstützung

  • Entwickeln Sie mit JavaScript, Python, Go oder Rust.

2. Stellen Sie unbegrenzt Projekte kostenlos bereit

  • Zahlen Sie nur für die Nutzung – keine Anfragen, keine Gebühren.

3. Unschlagbare Kosteneffizienz

  • Pay-as-you-go ohne Leerlaufgebühren.
  • Beispiel: 25 US-Dollar unterstützen 6,94 Millionen Anfragen bei einer durchschnittlichen Antwortzeit von 60 ms.

4. Optimierte Entwicklererfahrung

  • Intuitive Benutzeroberfläche für mühelose Einrichtung.
  • Vollautomatische CI/CD-Pipelines und GitOps-Integration.
  • Echtzeitmetriken und -protokollierung für umsetzbare Erkenntnisse.

5. Mühelose Skalierbarkeit und hohe Leistung

  • Automatische Skalierung zur einfachen Bewältigung hoher Parallelität.
  • Null Betriebsaufwand – konzentrieren Sie sich einfach auf das Bauen.

pic

Weitere Informationen finden Sie in der Dokumentation!

Leapcell Twitter: https://x.com/LeapcellHQ

Share this article

HackerNews

More Posts from Leapcell

cover

Jemalloc verstehen: Ein Rust Performance Booster

cover

Go Flag Bibliothek: Eine vollständige Anleitung zu CLI Argumenten

Popular Posts