Introduction détaillée aux méthodes de déploiement et de débogage de Golang

Ces dernières années, Golang est devenu un langage de plus en plus populaire et ses applications sont devenues de plus en plus répandues, attirant l'attention de nombreux développeurs. Cependant, pour les développeurs qui découvrent Golang, le déploiement et le débogage sont des problèmes difficiles à résoudre. Cet article présentera en détail les méthodes de déploiement et de débogage de Golang.

1. Déploiement

1. Compilation

Golang est un langage compilé et le code écrit doit être compilé dans un fichier exécutable avant de pouvoir être exécuté. Il existe deux méthodes de compilation : la compilation statique et la compilation dynamique. La compilation statique regroupera les bibliothèques requises par le programme dans un fichier exécutable. Le fichier exécutable est plus grand en taille, mais n'a pas besoin de s'appuyer sur des bibliothèques externes au moment de l'exécution, tandis que la compilation dynamique nécessite une liaison dynamique des fichiers de bibliothèque au moment de l'exécution et en termes de taille. du fichier exécutable est plus petit, mais nécessite une dépendance à l'égard de bibliothèques externes.

Compilation statique :

$ go build -o main main.go

Compilation dynamique :

$ go build -o main main.go -ldflags "-linkmode=external"

Parmi eux, le -linkmode=external Le paramètre indique les fichiers de bibliothèque requis pour la liaison dynamique.

2. Variables d'environnement

Dans Golang, l'outil de gestion de paquets par défaut est go mod, vous devez donc définir des variables d'environnement pour spécifier le chemin de stockage du code et la source de téléchargement. Dans les systèmes Linux, les variables d'environnement peuvent être définies en modifiant le fichier ~/.bash_profile.

export GO111MODULE=on
export Republican GOSUMDB signifie vérifier si le package de code téléchargé est la version officiellement publiée.

Docker

3. Docker peut nous aider à regrouper les programmes Golang en images pour un déploiement facile sur n'importe quelle plate-forme. Vous devez d'abord écrire un Dockerfile :

FROM golang:1.15.0-alpine

WORKDIR /app

COPY .

RUN go build -o main .
CMD ["/app/main"]

Parmi eux, FROM. spécifie la source de l'image ; WORKDIR spécifie le répertoire de travail ; COPY copie les fichiers du dossier actuel dans l'image ; RUN exécute la commande de compilation ;

Ensuite, exécutez la commande suivante :

$ docker build -t myapp .

$ docker run -p 8080:8080 myapp

Parmi eux, -t spécifie le nom de l'étiquette ; -p spécifie le mappage du port.

2. Débogage

Outils de débogage

1. Golang dispose d'un ensemble intégré d'outils de débogage - go outil pprof, qui peut nous aider à analyser l'utilisation du processeur et de la mémoire. Tout d'abord, vous devez importer le package pprof dans le code et ajouter le code d'analyse des performances :

import (

"net/http"
_ "net/http/pprof"

)

func main() {

go func() {
    http.ListenAndServe("0.0.0.0:6060", nil)
}()
// your code here

}

Parmi eux, pprof n'a pas besoin d'être appelé lors de l'importation, il enregistrera automatiquement l'itinéraire. Exécutez ensuite la commande suivante :

$ go tool pprof http://localhost:6060/debug/pprof/profile

Cette commande imprimera les résultats de l'analyse de l'utilisation du processeur dans la console.

Débogueur

2. Si une exception se produit dans le programme, vous pouvez utiliser le débogueur pour le déboguer. Il existe de nombreux débogueurs dans Golang. En voici deux types :

Débogueur GDB :

Vous devez spécifier le paramètre -g pour ajouter des informations de débogage lors de la compilation, puis exécuter la commande suivante :

$ gdb myapp

(gdb) break main.main

(gdb) run

En prenant le point d'arrêt comme exemple, lorsque l'exécution atteint le point d'arrêt, elle cessera de s'exécuter et passera en mode débogage.

Delve Debugger :

Delve est un débogueur puissant qui prend en charge le débogage à distance et le débogage réseau. Vous devez d'abord installer Delve :

$ go get -u github.com/go-delve/delve/cmd/dlv

Ensuite, exécutez la commande suivante pour démarrer le débogueur :

$ dlv debug myapp

Cette commande démarrez le débogueur et ouvrez une interface REPL (Read-Eval-Print Loop), et vous pouvez déboguer sous cette interface.

Résumé

Cet article présente les méthodes de déploiement et de débogage de Golang : compilation, variables d'environnement, Docker, pprof, GDB et Delve. J'espère que cela pourra aider les développeurs à mieux maîtriser les compétences Golang.

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!