Des projets Go-lang passionnants pour démarrer votre parcours DevOps

? Introduction

Bienvenue dans le monde du DevOps ! ? Aujourd'hui, je suis de retour avec un autre blog passionnant pour vous aider à approfondir la programmation pratique pour les tâches DevOps. Dans mon blog précédent, nous avons exploré 3 projets Python qui ont jeté les bases de l'automatisation DevOps.

Maintenant, changeons de sujet et explorons la puissance du Go-lang ! Ce blog vous guidera dans la construction de 3 projets Go-lang à la fois pratiques et adaptés aux débutants :

• Un outil Surveiller l'utilisation du disque pour suivre les statistiques de stockage.
• Hébergement d'un site Web de CV à l'aide d'un serveur HTTP.
• Un programme API RESTful pour gérer les outils DevOps.

Alors, prenez votre éditeur de code préféré et commençons ! ?

---

? Pré-requis

Avant de nous lancer dans la construction de ces projets, assurons-nous que votre environnement est configuré et prêt à fonctionner. Voici ce dont vous avez besoin :

1. Allez (Golang)
Vous devrez avoir Go installé sur votre système. Suivez ces étapes en fonction de votre système d'exploitation :

Windows

• Téléchargez le dernier programme d'installation de Go sur le site officiel.
• Exécutez le programme d'installation et suivez les instructions à l'écran.
• Vérifiez l'installation en ouvrant l'invite de commande ou PowerShell et en tapant :

go version

Ubuntu

• Ouvrez un terminal et exécutez :

sudo apt update  
sudo apt install -y golang

• Vérifiez l'installation :

go version

macOS

• Utilisez Homebrew pour installer Go. Courir:

brew install go

• Vérifiez l'installation :

go version

2. Compréhension de base de Go

Bien que vous n'ayez pas besoin d'être un expert, avoir une compréhension fondamentale des concepts Go tels que les variables, les fonctions et les structures vous aidera à suivre en douceur. Si vous êtes nouveau sur Go, je vous recommande d'explorer le Go Tour pour une introduction rapide.

Une fois ces conditions préalables remplies, vous êtes prêt à commencer à construire ces superbes projets Go-lang ! ?

---

? Application de surveillance de l'utilisation du disque

Commençons notre voyage avec le premier projet : un outil de surveillance de l'utilisation du disque. Ce programme vous aidera à analyser l'utilisation du disque pour n'importe quel répertoire spécifié sur votre système.

Vous pouvez trouver le code source dans mon référentiel GitHub. Commençons par créer un fichier nommé disk_usage.go et ajoutons le code suivant :

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

Comment fonctionne le programme :

• Le programme utilise la fonction syscall.Statfs pour récupérer les statistiques du disque, y compris l'espace total, utilisé et libre.
• Il calcule le pourcentage d'espace disque utilisé et formate la sortie de manière conviviale.
• La gestion des erreurs est implémentée pour vérifier si le chemin fourni existe ou s'il y a un problème pour y accéder.

Exécuter le programme
Pour exécuter le programme, utilisez les commandes suivantes :

• Vérifiez l'utilisation du disque d'un répertoire spécifique :

go version

• Si aucun chemin n'est spécifié, le programme utilise par défaut le répertoire racine (/) :

sudo apt update  
sudo apt install -y golang

Comme j'ai une seule partition, j'obtiendrai le même résultat si je fournis des chemins différents.

Ce projet montre comment Go peut interagir avec les API sous-jacentes de votre système, ce qui en fait un excellent point de départ pour les tâches de surveillance du système. ?

---

? Programme de serveur HTTP : hébergement d'un site Web Portfolio

Le deuxième projet consiste à créer un serveur HTTP dans Go qui héberge un site Web de portfolio. Ce projet montre comment vous pouvez créer et servir des sites Web statiques tout en incorporant un point de terminaison de vérification de l'état pour la surveillance.

Vous pouvez trouver le code source dans mon référentiel GitHub.

Étapes pour créer le serveur HTTP

• Créez un fichier nommé http_server.go et ajoutez le code suivant :

go version

Comment ça marche

• Serveur de fichiers statique : la fonction http.FileServer sert les fichiers du répertoire ./static.
• Point de terminaison du contrôle de santé : une route /health est définie pour fournir une métrique de contrôle de santé simple.
• Configuration du serveur : le serveur écoute sur le port 8090 par défaut et toutes les erreurs lors du démarrage sont enregistrées.

Création du site Web Portfolio

1. Structure : Dans le dossier statique, créez :

   • index.html
   • style.css
   • Un dossier nommé images avec une photo de profil nommée profile.jpeg.

2. Ajoutez le contenu suivant à vos fichiers :

index.html :

brew install go

Exécuter le programme

• Démarrez le serveur HTTP avec la commande suivante :

go version

• Le site Web de votre portfolio sera désormais disponible à l'adresse : hôte local : 8090

Accéder au bilan de santé
Pour vérifier la santé du serveur, visitez :

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

Ce projet montre comment utiliser Go-lang pour créer un serveur Web fonctionnel pour héberger du contenu statique, avec une surveillance supplémentaire via un point de terminaison de vérification de l'état. ?

---

? Projet API RESTful : gestion des outils DevOps

Dans le projet final de ce blog, nous créerons une API RESTful qui vous permettra de gérer une liste d'outils DevOps. Ce programme démontre l'utilisation du package net/http de Go pour gérer les routes RESTful et gérer les données.

Le code source complet est disponible sur mon dépôt GitHub.

Création de l'API RESTful
Étape 1 : Programme principal
Créez un fichier nommé main.go et ajoutez le code suivant :

go version

Étape 2 : Traitement des données
Dans le répertoire tools, créez un fichier nommé data.go et ajoutez :

sudo apt update  
sudo apt install -y golang

Étape 3 : Gestionnaires
Dans le répertoire tools, créez un autre fichier nommé handler.go et ajoutez :

go version

Initialisation du module

Avant d'exécuter le programme, initialisez le module Go :

brew install go

Cela garantit que le projet peut utiliser le package projet/outils.

Exécuter le programme
Démarrez le serveur en exécutant :

go version

Test de l'API

1. Liste de tous les outils Pour récupérer la liste des outils, utilisez :

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

Sortie :

go run disk_usage.go /path/to/directory

1. Ajouter un nouvel outil Pour ajouter un nouvel outil, utilisez :

go run disk_usage.go

Sortie :

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. Récupérer les détails de l'outil Pour récupérer les détails d'un outil spécifique, utilisez :

    <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;
}

Sortie :

go run http_server.go

---

? Conclusion

Dans ce blog, nous avons exploré trois projets Go pratiques qui vous aident à acquérir une expérience pratique de différents aspects du développement logiciel. De la surveillance de l'utilisation du disque à la création d'un simple serveur HTTP en passant par l'hébergement d'un site Web de portefeuille et enfin la création d'une API RESTful pour gérer les outils DevOps, ces projets constituent une base solide pour tous ceux qui cherchent à perfectionner leurs compétences en programmation Go.

• L'application de surveillance de l'utilisation du disque vous a présenté les appels système et la gestion de base des fichiers dans Go, vous donnant un aperçu de la façon dont vous pouvez interagir avec le système de fichiers d'une machine.
• Le projet de serveur HTTP vous a permis d'apprendre à servir des fichiers statiques et à gérer les points de terminaison de base de vérification de l'état, vous aidant ainsi à vous lancer dans le développement Web dans Go.
• Le Projet API RESTful a montré comment structurer une API, gérer les données avec contrôle de concurrence et rendre votre application interactive via les requêtes POST et GET.

Chacun de ces projets est un élément de base qui peut être étendu pour s'adapter à des applications du monde réel. Que vous soyez intéressé par la surveillance de systèmes, le développement d'applications Web ou la création d'API, Go offre la simplicité et la puissance nécessaires à un développement efficace.

? Pour un blog plus informatif, suivez-moi sur Hashnode, X(Twitter) et LinkedIn.

En attendant, bon codage !!

Bon apprentissage ! ?