Comment utiliser Golang pour déployer des applications

Ces dernières années, avec le développement rapide de la technologie du cloud computing, de plus en plus d'entreprises ont commencé à utiliser le cloud computing pour déployer des applications. En tant que langage de programmation rapide, efficace et facile à apprendre, Go (également connu sous le nom de golang) attire de plus en plus d'attention dans le développement cloud natif. Cet article présentera en détail comment utiliser Golang pour déployer des applications, dans le but d'aider les débutants à maîtriser rapidement les compétences de déploiement cloud de Golang.

Première partie : Stratégie de déploiement du cloud Golang

De nos jours, il est assez courant que les entreprises utilisent les services de fournisseurs de services de cloud computing (CSP) pour déployer des applications sur le cloud public . Bien entendu, chaque CSP peut proposer différentes stratégies de déploiement cloud. Lors de l'utilisation de Golang pour le déploiement dans le cloud, il existe deux stratégies principales, à savoir le déploiement d'applications Golang dans des conteneurs et le déploiement d'applications Golang à l'aide d'une architecture sans serveur.

Ce qui suit présentera en détail ces deux stratégies de déploiement cloud.

Partie 2 : Utiliser des conteneurs pour déployer des applications Golang

La virtualisation de conteneurs est une technologie utilisée pour implémenter la virtualisation au niveau du système d'exploitation informatique. Grâce à la technologie des conteneurs, plusieurs environnements peuvent coexister sur le même hôte physique, réduisant ainsi les coûts de déploiement et de gestion. Dans ce cas, l'application Golang est regroupée dans une image de conteneur, à l'aide d'un outil de gestion tel que Docker ou Kubernetes, et le conteneur est déployé sur le cloud ou l'hôte local. Ce qui suit décrit comment utiliser Docker et Kubernetes pour déployer des applications Golang.

2.1 Utilisez Docker pour déployer des applications Golang

Docker est actuellement une plateforme de conteneurisation très populaire. Pour les développeurs qui souhaitent déployer des applications Golang sur des conteneurs Docker, ils peuvent le faire en suivant les étapes suivantes.

Étape 1 : Installer Docker

Selon le système d'exploitation utilisé, vous pouvez visiter le site officiel de Docker pour télécharger et installer le programme d'installation de Docker correspondant.

Étape 2 : Créer un fichier Docker

Dans le Dockerfile, vous devez définir comment créer l'image Docker. Vous trouverez ci-dessous un exemple simple de Dockerfile qui montre comment déployer une application Golang nommée « hello-world ».

FROM golang:latest

ADD . /go/src/hello-world
WORKDIR /go/src/hello-world

RUN go install

ENTRYPOINT /go/bin/hello-world

EXPOSE 8080

Ce Dockerfile est divisé en plusieurs parties. Tout d’abord, il prend la dernière version de l’image golang comme image de base. Il utilise ensuite la directive ADD pour ajouter l'application au chemin /go/src/hello-world à l'intérieur du conteneur. Ensuite, il utilise la commande WORKDIR pour modifier le répertoire actuel en /go/src/hello-world, et utilise la commande RUN pour installer et créer l'application. Enfin, il utilise la directive ENTRYPOINT pour faire de l'application le point d'entrée du conteneur, et la directive EXPOSE pour spécifier le port sur lequel le conteneur va écouter.

Étape 3 : Créez l'image à l'aide de Docker

Utilisez la commande suivante pour créer une image nommée "hello-world" à partir du Dockerfile dans le répertoire racine du dossier de l'application.

$ docker build -t hello-world .

Cette commande demande à Docker de créer une image nommée "hello-world" en utilisant le Dockerfile dans le répertoire courant.

Étape 4 : Exécutez le conteneur de l'application

Maintenant, l'application a été empaquetée avec succès dans le conteneur et enregistrée en tant qu'image "hello-world". Vous pouvez maintenant utiliser la commande suivante pour exécuter le conteneur :

$ docker run -p 8080:8080 hello-world

Cette commande démarrera un nouveau conteneur et mappera le port 8080 du conteneur au port 8080 de la machine locale. À ce stade, vous pouvez accéder à l'application Golang qui s'exécute dans le conteneur Docker.

2.2 Utilisez Kubernetes pour déployer des applications Golang

Kubernetes est un outil de gestion open source qui automatise le déploiement, la gestion et l'expansion des conteneurs. Grâce à Kubernetes, le déploiement, la mise à l'échelle et la gestion conteneurisés des applications Golang peuvent être facilement effectués. Vous trouverez ci-dessous une étape simple pour déployer une application Golang sur Kubernetes.

Étape 1 : Créer un fichier de déploiement

Utilisez l'exemple yaml suivant pour créer un fichier de déploiement qui définit le déploiement des applications Golang et comment déployer le conteneur dans le cluster Kubernetes .

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
  labels:
    app: hello-world
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello-world
        image: golang:latest
        command: ["/bin/bash", "-c"]
        args: ["go run main.go"]
        ports:
        - containerPort: 8080

Dans cet exemple yaml, un déploiement nommé "hello-world" est défini, l'image du conteneur de l'application est spécifiée, les paramètres et les ports du conteneur sont définis et comment l'utiliser sur le cluster Kubernetes Déployez le conteneur.

Étape 2 : Déployez l'application Golang à l'aide de Kubernetes

Utilisez la commande kubectl apply pour appliquer le fichier de déploiement au cluster Kubernetes.

$ kubectl apply -f deployment.yaml

Une fois l'opération de déploiement terminée, Kubernetes se connectera à l'image de conteneur configurée et instanciera deux instances de conteneur de l'application golang.

Étape 3 : Accédez à l'application

Utilisez la commande kubectl suivante pour afficher l'état du déploiement nouvellement déployé.

$ kubectl get deployments

Cette commande affichera tous les déploiements en cours d'exécution dans le cluster.

Utilisez la commande suivante pour afficher les Pods de l'application.

$ kubectl get pods

Cette commande affichera tous les pods en cours d'exécution.

Utilisez la commande kubectl suivante pour afficher les services exposés.

$ kubectl expose deployment hello-world --type=LoadBalancer --port=8080

Cette commande crée un service appelé "hello-world" et l'expose derrière un LoadBalancer au sein du cluster Kubernetes.

Utilisez la commande kubectl suivante pour vérifier l'état du service exposé à ce moment.

$ kubectl get services

Cette commande affichera tous les services en cours d'exécution.

Étape 4 : Mise à l'échelle de l'application

Le nombre de répliques de l'application peut être étendu à 5 avec la commande suivante.

$ kubectl scale deployments/hello-world --replicas=5

Cette commande créera 5 conteneurs dans le cluster Kubernetes et distribuera la charge de l'application golang à toutes les instances de conteneur.

Partie 3 : Déploiement d'applications Golang à l'aide d'une architecture sans serveur

L'architecture sans serveur est un modèle informatique entièrement géré, dans lequel le fournisseur de services cloud prend uniquement en charge le code de l'application et n'est responsable d'aucune configuration ou maintenance côté serveur. Grâce à l'architecture sans serveur, l'ensemble de l'application peut être hébergée sur le cloud et gérée avec une consommation de ressources minimale. Les fournisseurs de services cloud sans serveur tels qu'AWS Lambda ont un excellent rapport prix/performance, vous permettant de payer uniquement en fonction de l'utilisation sans vous soucier des détails de l'infrastructure.

Voici les étapes simples pour utiliser AWS Lambda pour déployer une application Golang :

Étape 1 : Créer la fonction AWS Lambda

Créez une nouvelle fonction Lambda en utilisant Golang comme environnement d'exécution. Définissez la configuration et le code pour l'exécution de la fonction, et regroupez la fonction dans un fichier d'archive zip.

Étape 2 : Télécharger et tester la fonction

Téléchargez le fichier zip sur AWS Lambda et testez le code de l'application à l'aide de l'IDE en ligne d'AWS Lambda.

Étape 3 : Configurer l'API

Créez une passerelle API et associez-la à la fonction Lambda.

Étape 4 : tester API Gateway

Utilisez la fonction de déploiement d'AWS API Gateway pour déployer l'application sur le cloud et y accéder dans le navigateur.

Ces étapes sont un bon guide pour commencer à utiliser Golang pour le déploiement cloud. Bien entendu, dans la mise en œuvre réelle, vous rencontrerez plus de détails et de défis, tels que la manière d'optimiser les applications, de conteneuriser les opérations, etc. Cependant, les informations fournies dans cet article peuvent fournir aux débutants suffisamment de connaissances pour établir les bases du déploiement cloud et ouvrir la porte à des sujets plus approfondis.

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!