Comment utiliser Golang pour l'empaquetage et le déploiement

Avec le développement continu de la technologie Internet, de plus en plus d'entreprises commencent à utiliser Golang pour écrire des services back-end. Par rapport à d'autres langages, Golang présente de grands avantages en termes de traitement simultané et d'optimisation des performances. Le packaging et le déploiement sont un élément important d’une gestion efficace des projets Golang. Ensuite, cet article expliquera comment utiliser Golang pour l'empaquetage et le déploiement.

1. Utilisez Golang pour l'emballage

golang lui-même possède ses propres outils d'emballage et n'a pas besoin de s'appuyer sur des outils tiers. Pour utiliser golang pour l'empaquetage, il vous suffit d'exécuter les deux commandes suivantes :

go build -o output main.go

Parmi elles, le paramètre -o est utilisé pour spécifier le nom du fichier exécutable de sortie, et main.go est le document à compiler.

De plus, si vous devez déployer des applications sur différents systèmes d'exploitation, vous pouvez utiliser CGO pour la compilation croisée. Par exemple, si vous devez déployer sur Windows, vous pouvez exécuter la commande suivante :

CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o output.exe main.go

Parmi eux, CGO_ENABLED signifie désactiver CGO, car de nombreuses bibliothèques CGO ne peuvent pas être utilisées sur Windows ; GOOS signifie que le système d'exploitation cible est Windows ; GOARCH signifie que l'architecture CPU du système cible est AMD64.

Deuxièmement, utilisez Docker pour l'emballage

golang présente également certains avantages en matière de conteneurisation. L'utilisation de Docker pour l'empaquetage et le déploiement peut séparer l'application de l'environnement dont elle dépend, garantissant ainsi la portabilité et la cohérence de l'application.

Tout d'abord, vous devez écrire un fichier Dockerfile pour décrire le processus de construction et de déploiement de l'application. L'exemple est le suivant :

FROM golang:1.12-alpine

COPY /app

WORKDIR /app

RUN . go build -o main .

EXPOSE 8080

CMD ["./main"]

Parmi eux, l'instruction FROM est utilisée pour spécifier l'image de base comme golang:1.12-alpine l'instruction COPY est utilisée pour tout copier ; les fichiers du répertoire actuel vers le répertoire de l'application ; l'instruction WORKDIR est utilisée pour basculer vers le répertoire de l'application ; l'instruction RUN est utilisée pour exécuter la commande go build pour construire ; l'instruction EXPOSE est utilisée pour exposer le port ; est utilisé pour démarrer l'application.

Ensuite, exécutez la commande suivante pour empaqueter :

docker build -t myapp:latest .

Parmi eux, le paramètre -t est utilisé pour spécifier le nom de l'image et le numéro de version, et représente le répertoire actuel. Une fois l'empaquetage terminé, vous pouvez démarrer le conteneur via la commande suivante :

docker run -d -p 8080:8080 myapp:latest

Parmi eux, le paramètre -d est utilisé pour exécuter le conteneur en arrière-plan, et le Le paramètre -p est utilisé pour mapper le port 8080 du conteneur au port 8080 de la machine hôte.

3. Déployer à l'aide de Kubernetes

Kubernetes est un outil d'orchestration de conteneurs open source qui peut être utilisé pour automatiser le déploiement, l'expansion et la gestion d'applications conteneurisées. Le déploiement avec Kubernetes améliore la fiabilité et la résilience des applications.

Tout d'abord, vous devez écrire un fichier de déploiement.yaml pour décrire l'implémentation du déploiement de l'application. L'exemple est le suivant :

apiVersion : apps/v1
kind : Deployment
metadata :
name : myapp
spec:
. selector:

matchLabels:
  app: myapp

replicas: 3
template:

metadata:
  labels:
    app: myapp
spec:
  containers:
  - name: myapp
    image: myregistry/myapp:latest
    ports:
    - containerPort: 8080

Parmi eux, apiVersion représente la version API de la ressource, et kind représente le type de ressource comme Déploiement ; le champ de nom est utilisé pour spécifier le nom du déploiement ; utilisé pour spécifier quels pods sont sélectionnés ; le champ répliques est utilisé pour spécifier le nombre de pods à créer ; le champ modèle est utilisé pour spécifier le modèle du Pod ; le champ conteneurs est utilisé pour inclure un ou plusieurs conteneurs l'image ; Le champ est utilisé pour spécifier l'image du conteneur ; le champ ports est utilisé pour spécifier le port sur lequel le conteneur écoute.

Ensuite, exécutez la commande suivante pour déployer :

kubectl apply -f déploiement.yaml

Parmi eux, le paramètre -f est utilisé pour spécifier le chemin du fichier de déploiement. Une fois le déploiement terminé, vous pouvez afficher l'état du déploiement via la commande suivante :

kubectl get pods

Enfin, vous pouvez créer un objet de service via la commande suivante pour exposer le port dans le conteneur aux utilisateurs externes :

kubectl exposer le déploiement myapp --type=LoadBalancer --name=myapp-service

Parmi eux, le paramètre --type est utilisé pour spécifier le type de service LoadBalancer indique que le service est exposé en externe via l'équilibreur de charge du fournisseur de cloud ; Le paramètre -name est utilisé pour spécifier le nom du service.

Résumé

Cet article présente trois méthodes d'utilisation de Golang pour l'empaquetage et le déploiement : utiliser le propre outil d'empaquetage de Golang, utiliser Docker pour l'empaquetage et utiliser Kubernetes pour le déploiement. Ces méthodes peuvent essentiellement répondre aux besoins de différents scénarios. J'espère qu'elles pourront vous fournir une référence pour développer et déployer des projets 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!