Spannende Go-Lang-Projekte für den Kickstart Ihrer DevOps-Reise

? Einführung

Willkommen in der Welt von DevOps! ? Heute bin ich mit einem weiteren spannenden Blog zurück, der Ihnen dabei helfen soll, tiefer in die praktische Programmierung für DevOps-Aufgaben einzutauchen. In meinem vorherigen Blog haben wir drei Python-Projekte untersucht, die den Grundstein für die DevOps-Automatisierung legten.

Jetzt schalten wir den Gang um und entdecken die Kraft von Go-lang! Dieser Blog führt Sie durch die Erstellung von 3 Go-Lang-Projekten, die sowohl praktisch als auch anfängerfreundlich sind:

• Ein Überwachen Sie die Festplattennutzung-Tool zum Verfolgen von Speicherstatistiken.
• Hosten einer Lebenslauf-Website über einen HTTP-Server.
• Ein RESTful-API-Programm zur Verwaltung von DevOps-Tools.

Also schnappen Sie sich Ihren bevorzugten Code-Editor und legen wir los! ?

---

? Voraussetzungen

Bevor wir mit dem Aufbau dieser Projekte beginnen, stellen wir sicher, dass Ihre Umgebung eingerichtet und einsatzbereit ist. Das brauchen Sie:

1. Geh (Golang)
Sie müssen Go auf Ihrem System installiert haben. Befolgen Sie je nach Betriebssystem die folgenden Schritte:

Windows

• Laden Sie das neueste Go-Installationsprogramm von der offiziellen Website herunter.
• Führen Sie das Installationsprogramm aus und befolgen Sie die Anweisungen auf dem Bildschirm.
• Überprüfen Sie die Installation, indem Sie die Eingabeaufforderung oder PowerShell öffnen und Folgendes eingeben:

go version

Ubuntu

• Öffnen Sie ein Terminal und führen Sie Folgendes aus:

sudo apt update  
sudo apt install -y golang

• Überprüfen Sie die Installation:

go version

macOS

• Verwenden Sie Homebrew, um Go zu installieren. Laufen:

brew install go

• Überprüfen Sie die Installation:

go version

2. Grundlegendes Verständnis von Go

Obwohl Sie kein Experte sein müssen, hilft Ihnen ein grundlegendes Verständnis der Go-Konzepte wie Variablen, Funktionen und Strukturen dabei, reibungslos voranzukommen. Wenn Sie neu bei Go sind, empfehle ich Ihnen, die Go-Tour für einen schnellen Einstieg zu erkunden.

Wenn diese Voraussetzungen erfüllt sind, können Sie mit der Erstellung dieser fantastischen Go-Lang-Projekte beginnen! ?

---

? App zur Überwachung der Festplattennutzung

Beginnen wir unsere Reise mit dem ersten Projekt – einem Tool zur Überwachung der Festplattennutzung. Dieses Programm hilft Ihnen bei der Analyse der Festplattennutzung für jedes angegebene Verzeichnis auf Ihrem System.

Den Quellcode finden Sie in meinem GitHub-Repository. Beginnen wir damit, eine Datei mit dem Namen disk_usage.go zu erstellen und den folgenden Code hinzuzufügen:

package main

import (
    "fmt"
    "os"
    "syscall"
)
func getDiskUsage(path string) {
    var stat syscall.Statfs_t
    err := syscall.Statfs(path, &stat)
    if err != nil {
        fmt.Println("Error Fetching Disk Usage:", err)
        return
    }
    total := stat.Blocks * uint64(stat.Bsize)
    free := stat.Bfree * uint64(stat.Bsize)
    used := total - free
    percentUsed := float64(used) / float64(total) * 100
    fmt.Printf("Disk usage of %s:\n", path)
    fmt.Printf("Total: %d GB\n", total/1e9)
    fmt.Printf("Used: %d GB (%.2f%%)\n", used/1e9, percentUsed)
    fmt.Printf("Free: %d GB\n", free/1e9)
}
func main() {
    path := "/"
    if len(os.Args) > 1 {
        path = os.Args[1]
    }
    _, err := os.Stat(path)
    if os.IsNotExist(err) {
        fmt.Printf("Error: '%s' Path doesn't exist.\n", path)
        return
    } else if err != nil {
        fmt.Printf("Error occurred while accessing path %s: %v \n", path, err)
        return
    }
    getDiskUsage(path)
}

So funktioniert das Programm:

• Das Programm verwendet die Funktion syscall.Statfs, um Festplattenstatistiken abzurufen, einschließlich des gesamten, verwendeten und freien Speicherplatzes.
• Es berechnet den Prozentsatz des verwendeten Speicherplatzes und formatiert die Ausgabe auf benutzerfreundliche Weise.
• Eine Fehlerbehandlung ist implementiert, um zu prüfen, ob der angegebene Pfad existiert oder ob beim Zugriff darauf ein Problem vorliegt.

Ausführen des Programms
Um das Programm auszuführen, verwenden Sie die folgenden Befehle:

• Überprüfen Sie die Festplattennutzung eines bestimmten Verzeichnisses:

go version

• Wenn kein Pfad angegeben ist, verwendet das Programm standardmäßig das Stammverzeichnis (/):

sudo apt update  
sudo apt install -y golang

Da ich eine einzelne Partition habe, erhalte ich das gleiche Ergebnis, wenn ich verschiedene Pfade angebe.

Dieses Projekt zeigt, wie Go mit den zugrunde liegenden APIs Ihres Systems interagieren kann, was es zu einem hervorragenden Ausgangspunkt für Systemüberwachungsaufgaben macht. ?

---

? HTTP-Serverprogramm: Hosten einer Portfolio-Website

Das zweite Projekt umfasst die Erstellung eines HTTP-Servers in Go, der eine Portfolio-Website hostet. Dieses Projekt zeigt, wie Sie statische Websites erstellen und bereitstellen und gleichzeitig einen Health-Check-Endpunkt zur Überwachung integrieren können.

Den Quellcode finden Sie in meinem GitHub-Repository.

Schritte zum Erstellen des HTTP-Servers

• Erstellen Sie eine Datei mit dem Namen http_server.go und fügen Sie den folgenden Code hinzu:

go version

Wie es funktioniert

• Statischer Dateiserver: Die http.FileServer-Funktion stellt Dateien aus dem ./static-Verzeichnis bereit.
• Integritätsprüfungsendpunkt: Eine /health-Route wird definiert, um eine einfache Integritätsprüfungsmetrik bereitzustellen.
• Server-Setup: Der Server überwacht standardmäßig Port 8090 und alle Fehler während des Startvorgangs werden protokolliert.

Erstellen der Portfolio-Website

1. Struktur: Erstellen Sie im statischen Ordner Folgendes:

   • index.html
   • style.css
   • Ein Ordner namens „images“ mit einem Profilbild namens „profile.jpeg“.

2. Fügen Sie den folgenden Inhalt zu Ihren Dateien hinzu:

index.html:

brew install go

Ausführen des Programms

• Starten Sie den HTTP-Server mit dem folgenden Befehl:

go version

• Ihre Portfolio-Website ist jetzt verfügbar unter: localhost:8090

Zugriff auf den Gesundheitscheck
Um den Zustand des Servers zu überprüfen, besuchen Sie:

package main

import (
    "fmt"
    "os"
    "syscall"
)
func getDiskUsage(path string) {
    var stat syscall.Statfs_t
    err := syscall.Statfs(path, &stat)
    if err != nil {
        fmt.Println("Error Fetching Disk Usage:", err)
        return
    }
    total := stat.Blocks * uint64(stat.Bsize)
    free := stat.Bfree * uint64(stat.Bsize)
    used := total - free
    percentUsed := float64(used) / float64(total) * 100
    fmt.Printf("Disk usage of %s:\n", path)
    fmt.Printf("Total: %d GB\n", total/1e9)
    fmt.Printf("Used: %d GB (%.2f%%)\n", used/1e9, percentUsed)
    fmt.Printf("Free: %d GB\n", free/1e9)
}
func main() {
    path := "/"
    if len(os.Args) > 1 {
        path = os.Args[1]
    }
    _, err := os.Stat(path)
    if os.IsNotExist(err) {
        fmt.Printf("Error: '%s' Path doesn't exist.\n", path)
        return
    } else if err != nil {
        fmt.Printf("Error occurred while accessing path %s: %v \n", path, err)
        return
    }
    getDiskUsage(path)
}

Dieses Projekt zeigt, wie man mit Go-lang einen funktionsfähigen Webserver zum Hosten statischer Inhalte erstellt, mit zusätzlicher Überwachung durch einen Endpunkt zur Gesundheitsprüfung. ?

---

? RESTful API-Projekt: DevOps-Tools verwalten

Im letzten Projekt dieses Blogs erstellen wir eine RESTful-API, mit der Sie eine Liste von DevOps-Tools verwalten können. Dieses Programm demonstriert die Verwendung des Net/http-Pakets von Go zur Verarbeitung von RESTful-Routen und zur Datenverwaltung.

Der vollständige Quellcode ist in meinem GitHub-Repository verfügbar.

Erstellen der RESTful API
Schritt 1: Hauptprogramm
Erstellen Sie eine Datei mit dem Namen main.go und fügen Sie den folgenden Code hinzu:

go version

Schritt 2: Datenverarbeitung
Erstellen Sie im Tools-Verzeichnis eine Datei mit dem Namen data.go und fügen Sie Folgendes hinzu:

sudo apt update  
sudo apt install -y golang

Schritt 3: Handler
Erstellen Sie im Tools-Verzeichnis eine weitere Datei mit dem Namen handler.go und fügen Sie hinzu:

go version

Initialisierung des Moduls

Bevor Sie das Programm ausführen, initialisieren Sie das Go-Modul:

brew install go

Dadurch wird sichergestellt, dass das Projekt das Projekt-/Tools-Paket verwenden kann.

Ausführen des Programms
Starten Sie den Server, indem Sie Folgendes ausführen:

go version

Testen der API

1. Alle Werkzeuge auflisten Um die Liste der Tools abzurufen, verwenden Sie:

package main

import (
    "fmt"
    "os"
    "syscall"
)
func getDiskUsage(path string) {
    var stat syscall.Statfs_t
    err := syscall.Statfs(path, &stat)
    if err != nil {
        fmt.Println("Error Fetching Disk Usage:", err)
        return
    }
    total := stat.Blocks * uint64(stat.Bsize)
    free := stat.Bfree * uint64(stat.Bsize)
    used := total - free
    percentUsed := float64(used) / float64(total) * 100
    fmt.Printf("Disk usage of %s:\n", path)
    fmt.Printf("Total: %d GB\n", total/1e9)
    fmt.Printf("Used: %d GB (%.2f%%)\n", used/1e9, percentUsed)
    fmt.Printf("Free: %d GB\n", free/1e9)
}
func main() {
    path := "/"
    if len(os.Args) > 1 {
        path = os.Args[1]
    }
    _, err := os.Stat(path)
    if os.IsNotExist(err) {
        fmt.Printf("Error: '%s' Path doesn't exist.\n", path)
        return
    } else if err != nil {
        fmt.Printf("Error occurred while accessing path %s: %v \n", path, err)
        return
    }
    getDiskUsage(path)
}

Ausgabe:

go run disk_usage.go /path/to/directory

1. Fügen Sie ein neues Tool hinzu Um ein neues Tool hinzuzufügen, verwenden Sie:

go run disk_usage.go

Ausgabe:

package main
import (
    "fmt"
    "net/http"
)
func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("OK"))
}
func main() {
    fs := http.FileServer(http.Dir("./static"))
    http.Handle("/", fs)
    http.HandleFunc("/health", healthCheckHandler)
    port := "8090"
    fmt.Printf("Starting server on port %s....", port)
    err := http.ListenAndServe(":"+port, nil)
    if err != nil {
        fmt.Println("Error starting server:", err)
    }
}

1. Werkzeugdetails abrufen Um Details zu einem bestimmten Tool abzurufen, verwenden Sie:

    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Pravesh Sudha - Portfolio</title>
    <link rel="stylesheet" href="style.css">


    <header>
        <div>



<p><strong>style.css:</strong><br>
</p>

<pre class="brush:php;toolbar:false">body {
    font-family: Arial, sans-serif;
    margin: 0;
    padding: 0;
    line-height: 1.6;
    color: #333;
    background-color: #f9f9f9;
}

header {
    background: #4caf50;
    color: #fff;
    padding: 20px 0;
    text-align: center;
}
header .profile-picture {
    width: 150px;
    height: 150px;
    border-radius: 50%;
    margin-bottom: 15px;
}
header h1 {
    font-size: 2.5em;
    margin: 0;
}
header .subtitle {
    font-size: 1.2em;
    margin: 0;
}
main {
    padding: 20px;
    max-width: 800px;
    margin: 20px auto;
    background: #fff;
    border-radius: 8px;
    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
}
main .about,
main .links {
    margin-bottom: 20px;
}
main .links ul {
    list-style: none;
    padding: 0;
}
main .links li {
    margin: 10px 0;
}
main .links a {
    color: #4caf50;
    text-decoration: none;
    font-weight: bold;
}
main .links a:hover {
    text-decoration: underline;
}
footer {
    text-align: center;
    padding: 10px 0;
    background: #333;
    color: #fff;
}

Ausgabe:

go run http_server.go

---

? Abschluss

In diesem Blog haben wir drei praktische Go-Projekte untersucht, die Ihnen helfen, praktische Erfahrungen mit verschiedenen Aspekten der Softwareentwicklung zu sammeln. Von der Überwachung der Festplattennutzung über den Aufbau eines einfachen HTTP-Servers bis hin zum Hosten einer Portfolio-Website und schließlich der Erstellung einer RESTful-API zur Verwaltung von DevOps-Tools bieten diese Projekte eine solide Grundlage für alle, die ihre Go-Programmierkenntnisse verbessern möchten.

• Die Anwendung zur Überwachung der Festplattennutzung führte Sie in die Systemaufrufe und die grundlegende Dateiverwaltung in Go ein und gab Ihnen Einblick, wie Sie mit dem Dateisystem einer Maschine interagieren können.
• Das HTTP-Serverprojekt ermöglichte es Ihnen, zu lernen, wie man statische Dateien bereitstellt und mit grundlegenden Endpunkten für die Zustandsprüfung umgeht, was Ihnen den Einstieg in die Webentwicklung in Go erleichterte.
• Das RESTful API-Projekt hat gezeigt, wie Sie eine API strukturieren, Daten mit Parallelitätskontrolle verwalten und Ihre Anwendung durch POST- und GET-Anfragen interaktiv machen.

Jedes dieser Projekte ist ein Baustein, der erweitert werden kann, um ihn an reale Anwendungen anzupassen. Egal, ob Sie sich für die Überwachung von Systemen, die Entwicklung von Webanwendungen oder die Erstellung von APIs interessieren, Go bietet die Einfachheit und Leistung, die für eine effiziente Entwicklung erforderlich sind.

? Für einen informativeren Blog folgen Sie mir auf Hashnode, X(Twitter) und LinkedIn.

Bis dahin viel Spaß beim Programmieren!!

Viel Spaß beim Lernen! ?