Développement local et tests avec Vagrant et Docker dans Beego

À mesure que la technologie du cloud computing et de la virtualisation continue de mûrir, de plus en plus de développeurs commencent à utiliser la technologie de virtualisation pour le développement et les tests locaux. La technologie de virtualisation permet d'isoler les environnements de développement et rend plus pratique et plus flexible la gestion et le développement de plusieurs environnements. Cet article vous présentera comment configurer un environnement de développement Vagrant + Docker lors de l'utilisation du framework Beego pour le développement et les tests locaux.

Que sont Vagrant et Docker ?

Vagrant est une technologie de virtualisation qui vous permet de créer et de gérer rapidement un environnement de développement virtualisé. Vagrant peut prendre en charge différents moteurs virtuels (par exemple, VirtualBox, VMware, Hyper-V, etc.), vous pouvez donc choisir le moteur qui convient à votre environnement de développement actuel pour exécuter votre environnement de développement virtuel.

Docker est une technologie de conteneurisation qui vous aide à créer, déployer et exécuter rapidement des applications et des services. Les conteneurs Docker peuvent s'exécuter dans n'importe quel environnement et fournir de puissants mécanismes d'isolation de l'environnement et de contrôle de version.

Pourquoi utiliser Vagrant + Docker pour le développement et les tests locaux ?

Lorsque nous devons tester notre code dans plusieurs environnements, nous devons développer et tester aussi précisément que l'environnement de production, en particulier les différences et la configuration de chaque environnement doivent être cohérentes avec l'environnement de production. Dans ce cas, l'utilisation de Vagrant + Docker peut aider les développeurs à effectuer des travaux de test et de maintenance complexes dans plusieurs environnements sans se soucier des incohérences dans les paramètres d'environnement et des erreurs causées par une mauvaise utilisation.

Installer Vagrant et Docker

Avant de commencer à utiliser Vagrant + Docker, vous devez installer ces deux outils sur votre machine. Les deux outils disposent d'une bonne documentation et d'un support communautaire, donc pendant le processus d'installation, vous devez faire attention aux étapes suivantes :

1. Entrez sur le [site officiel de Vagrant](https://www.vagrantup.com/downloads) et téléchargez Vagrant .
2. Selon le système d'exploitation que vous utilisez actuellement, téléchargez et installez Docker à partir du [site officiel de Docker](https://docs.docker.com/engine/install/). Notez qu’il est nécessaire de mettre en place une image Docker.

Configuration de l'environnement Docker dans Vagrant

Avec les étapes ci-dessus, vous avez installé avec succès Vagrant et Docker, et vous pouvez désormais utiliser Vagrant pour exécuter une nouvelle machine virtuelle, qui aura un environnement d'exécution Docker. Avant d'utiliser Vagrant pour exécuter la machine virtuelle, nous devons configurer le fichier Vagrant :

Vagrant.configure("2") do |config|

  config.vm.box = "ubuntu/focal64"
  config.vm.network "forwarded_port", guest: 8080, host: 8080

  config.vm.provider "virtualbox" do |vb|
    vb.memory = "2048"
    vb.cpumax = "2"
    vb.cpus = "1"
  end

  config.vm.provision "docker"
end

Le fichier de configuration ci-dessus signifie :

1. Utiliser ubuntu/focal64 comme système d'exploitation de la machine virtuelleubuntu/focal64 作为虚拟机的操作系统
2. 将虚拟机的 8080 端口映射到主机的 8080 端口上
3. 分配给虚拟机的内存大小是 2048MB
4. 虚拟机分配的 CPU 是 2 个核。

启动 Vagrant 虚拟机

现在，执行以下命令以启动 Vagrant 虚拟机：

vagrant up

在执行此命令后，Vagrant 将自动下载安装 Ubuntu 虚拟机，这个过程可能需要一些时间。安装完成后，您将可以使用以下命令通过 SSH 登录到 Vagrant 虚拟机：

vagrant ssh

使用 Docker 运行 Beego 应用程序

通过以上操作，您已经成功创建了一个具有 Docker 运行环境的虚拟机。接下来，你可以使用 Docker 运行您的 Beego 应用程序，您需要遵循以下步骤：

1. 在 Vagrant 虚拟机中使用 git clone 命令下载您的 Beego 应用程序源代码。
2. 在您的 Beego 应用程序的根目录创建名为 Dockerfile 的文件。Dockerfile 将包含一些指令来构建 Docker 容器。下面是一个例子：

FROM golang:1.16

ENV GOPATH /go
ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH

RUN apt-get update && apt-get -y install build-essential git-all

RUN mkdir -p $GOPATH/src/${MY_APP_PATH}/
ADD . $GOPATH/src/${MY_APP_PATH}/

WORKDIR $GOPATH/src/${MY_APP_PATH}/
RUN go install ${MY_APP_PATH}

ENTRYPOINT ${GOPATH}/bin/${MY_APP}

在这个Dockerfile中，我们使用 Golang-1.16 作为基于镜像，并下载安装了一些必要的依赖。然后，我们复制所有源代码到镜像中，并使用 golang 的 go install 命令构建安装您的 Beego 应用程序。在容器启动时，Beego 应用程序作为入口点（Entry Point）启动

3. 构建容器。在 Beego 应用程序的根目录下，运行以下命令：

docker build --build-arg MY_APP_PATH=github.com/your-username/your-app -t my-app-name:v1 .

4. 运行容器。在 Beego 应用程序的根目录下，运行以下命令：

docker run --rm -it -v $(pwd):/go/src/github.com/your-username/your-app -p 8080:8080 my-app-name:v1

在这个命令中，我们将当前目录绑定到容器中的 /go/src/github.com/your-username/your-app

Changer le port 8080 de la machine virtuelle Mappé sur le port 8080 de l'hôte

La taille de la mémoire allouée à la machine virtuelle est de 2048 Mo

Le CPU alloué à la machine virtuelle est de 2 cœurs. 🎜🎜🎜Démarrez la machine virtuelle Vagrant🎜🎜Maintenant, exécutez la commande suivante pour démarrer la machine virtuelle Vagrant : 🎜rrreee🎜Après avoir exécuté cette commande, Vagrant téléchargera et installera automatiquement la machine virtuelle Ubuntu. Ce processus peut prendre un certain temps. Une fois l'installation terminée, vous pourrez vous connecter à la machine virtuelle Vagrant via SSH à l'aide de la commande suivante : 🎜rrreee🎜Utilisez Docker pour exécuter l'application Beego🎜🎜Avec les opérations ci-dessus, vous avez réussi à créer une machine virtuelle avec un environnement d'exécution Docker. Ensuite, vous pouvez exécuter votre application Beego à l'aide de Docker, vous devez suivre les étapes suivantes : 🎜🎜🎜Utilisez la commande git clone dans la machine virtuelle Vagrant pour télécharger le code source de votre application Beego. 🎜🎜Créez un fichier nommé Dockerfile dans le répertoire racine de votre application Beego. Le Dockerfile contiendra des instructions pour créer un conteneur Docker. Voici un exemple : 🎜🎜rrreee🎜Dans ce Dockerfile, nous utilisons Golang-1.16 comme image de base, et téléchargeons et installons certaines dépendances nécessaires. Nous copions ensuite tout le code source dans l'image et créons et installons votre application Beego à l'aide de la commande go install de golang. Lorsque le conteneur démarre, l'application Beego démarre comme point d'entrée🎜

🎜Construisez le conteneur. Dans le répertoire racine de l'application Beego, exécutez la commande suivante : 🎜🎜rrreee
🎜Exécutez le conteneur. Dans le répertoire racine de votre application Beego, exécutez la commande suivante : 🎜🎜rrreee🎜Dans cette commande, nous lions le répertoire courant à /go/src/github.com/your-username/your-app répertoire, afin que les modifications de code soient mises à jour de manière synchrone dans le conteneur. En même temps, mappez le port 8080 du conteneur au port 8080 de l'hôte afin que nous puissions accéder à l'application Beego dans le conteneur depuis le navigateur. 🎜🎜Résumé🎜🎜Les étapes ci-dessus peuvent vous aider à comprendre comment utiliser Vagrant + Docker pour configurer un environnement de débogage afin de vous faciliter le développement et le test de la même manière que l'environnement de production. Un environnement de développement local approprié peut accélérer votre développement et votre processus, briser les limites et innover avec des idées plus fantastiques. 🎜

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!