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 :
Alors, prenez votre éditeur de code préféré et commençons ! ?
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
go version
Ubuntu
sudo apt update sudo apt install -y golang
go version
macOS
brew install go
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 ! ?
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 :
Exécuter le programme
Pour exécuter le programme, utilisez les commandes suivantes :
go version
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. ?
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
go version
Comment ça marche
Création du site Web Portfolio
Structure : Dans le dossier statique, créez :
Ajoutez le contenu suivant à vos fichiers :
index.html :
brew install go
Exécuter le programme
go version
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. ?
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
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
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)
}
}
<!DOCTYPE html>
<html lang="en">
<head>
<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">
</head>
<body>
<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
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.
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 ! ?
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!
Quelle pièce est le NFT ?
Méthode d'implémentation de la fonction js barrage
Comment arrêter après avoir exécuté la commande nohup
Comment basculer entre pleine largeur et demi-largeur
Méthodes d'analyse des données
Quelle est la différence entre RabbitMQ et Kafka
qu'est-ce que la plage Python
exigences de configuration matérielle du serveur Web
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
