L'effet final est le suivant
Il y a environ quelques étapes
1. Installer Docker CE 2. Exécuter Redis Image 3. Préparation de l'environnement Java 4. Préparation du projet 5. Écrivez Dockerfile 6. Project de version 7. Service de test
Préparation environnementale
1. Installer Docker CE
Ne recommandez pas de l'utiliser en Chine: "Scripts pour l'installation", il sera téléchargé et installé très lentement. Utilisez l'étape 1 pour l'installer, voir le lien suivant: Méthode d'installation générale
1. Méthode d'installation régulière
Ubuntu 17.04 x64 Installer Docker CE
http://www.ymq.io/2018/01/11/docker-install-docker-ce
2. Installez le script
Les scripts ne sont pas recommandés pour l'installation domestique:
Installer Docker CE
$ curl -fssl get.docker.com -o get-docker.sh $ sudo sh get-docker.sh
<Output tronqué> Si vous souhaitez utiliser Docker en tant qu'utilisateur non ROOT, vous devriez maintenant envisager votre utilisateur au groupe "Docker" avec quelque chose comme: Sudo Usermod -AG Docker votre utilisateur au groupe "Docker" à exécuter les contenants qui peuvent être utilisés pour obtenir des privilèges de racine. Reportez-vous à https://docs.docker.com/ngine/security/security/#docker-daemon-attack-surface pour plus d'informations.
Vérifiez Docker CE
Vérifiez que Docker CE est installé correctement en exécutant Hello-World Image
$ sudo docker run hello-worldroot @ suyunku: ~ # sudo docker imagesRepository tag id d'image créé sizehello-world Dernier f2a91732366c il y a 7 semaines 1.85KB
2. Exécutez l'image Redis
1. Exécutez le miroir
$ docker run --name redis-6379 -p 6379: 6379 -d redisunable pour trouver l'image 'redis: dernier' LocallyLatest: tire de la bibliothèque / redisc4bb02b17bb4: pull complet 58638ACF67C5: Pull complet F98D108CC38B: Pull Complete 83BE14FCCB07: Pull Tull Complete Complete 5d5f41793421: Pull complet ED89FF0D9EB2: Pull Complete Digest: Sha256: 0e773022CD6572A5153E5013AFCED0F7191652D3CDF9B1C6785EB13F6B2974B1STATU Redis: Dermter2F1F20F672E386A61644E1C08232EA34BDFD6A0C244B55FA833FCFD6DD207288
2. Vérifiez le miroir
Afficher le miroir
root @ Souyunku: ~ # Docker Images RedisRepository Tag ID d'image Créé SizerEdis Dernier 1E70071F4AF4 Il y a 4 semaines 107MB
Afficher le processus miroir
root @ Souyunku: ~ # docker pscontainer id Commande d'image Créé les ports d'état nom2f1f20f672e3 redis "docker-entrypoint.s ..." il y a 14 secondes en haut de 14 secondes 0.0.0.0:6379->6379/tcp redis-6379
Afficher le processus de conteneur
root @ Souyunku: ~ # Docker Container PSContainer ID Commande d'image Créé les ports d'état noms2f1f20f672e3 redis "docker-entrypoint.s ..." il y a 7 minutes 7 minutes 0.0.0: 6379-> 6379 / TCP redis-6379
3. Tester Redis Service
Connectez-vous au service Redis via Redis-CLI pour tester les données du magasin
root @ Souyunku: ~ # docker run -it --kink redis-6379: redis --rm redis redis-Cli -h redis -p 6379redis: 6379> set Count 1Okredis: 6379> Get Count "1" redis: 6379> exitroot @ souyunku: ~ # #
3. Préparation de l'environnement Java
Remarque: Lisez les étapes suivantes! ! !
1. L'environnement Java consiste à compiler le projet GHITHUB MAVEN SNGRAPOOT et à préparer
2. Ou vous pouvez compiler et télécharger localement par vous-même. Installez ensuite l'environnement Java suivant: JDK, Maven, Git, et vous pouvez faire sans configuration.
1. Installer JDK
Télécharger la méthode JDK: 1
Téléchargez JDK1.8 dans Linux Environment, veuillez vous rendre sur (site officiel) pour télécharger le fichier d'installation JDK
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
Télécharger la méthode JDK: 2
Mon lien dans Baidu Cloud Disk: http://pan.baidu.com/s/1jifzf9s Mot de passe: U4N4
Télécharger la méthode JDK: 3
Utilisez wget pour télécharger,
$ wget --no-cookies --no-cocheck-certificate --header "cookie: gpw_e24 = http% 3a% 2f% 2fwww.oracle.com% 2f; oracelisense = accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u141-b15/336fa29ff2bb4ef291e347e091f7f4a7/jdk-8u141-linux-x64.tar.gz
Remarque, si vous utilisez: Téléchargez la méthode JDK: 3
Ensuite, dans les étapes suivantes, JDK1.8.0_144 est remplacé par JDK1.8.0_141
Démarrer l'installation
Téléchargement dans le répertoire / opt
Décompression
$ cd / opt $ tar zxvf jdk-8u144-linux-x64.tar.gz $ mv jdk1.8.0_144 / / lib / jvm
Configurer les variables d'environnement
$ vi / etc.
Rendre les variables d'environnement efficaces
$ source / etc / profil
vérifier
Root @ Souyunku: ~ # Java -VersionJava Version "1.8.0_141" Java (TM) SE Runtime Environment (build 1.8.0_141-b15) Java Hotspot (TM) 64 bits VM (build 25.141-b15, mode mixte)
2. Installer Maven
$ apt-get install maven
Vérifiez Maven
root @ Souyunku: ~ # mvn -vapache maven 3.3.9maven home: / usr / share / mavenjava version: 1.8.0_141, vendeur: Oracle Corporationjava Home: / lib / jvm / jredefault locale: en_us, plateforme Encoding: utf-8os name: "Linux", version: "4.10.0-35-greeric, nom:" Linux ", version:" 4.10.0-35 "AMD64", famille: "Unix"
3. Installer Git
$ apt-get install git
Vérifiez Maven
root @ suyunku: ~ # git --versiongit version 2.11.0
4. Préparation du projet
1. Compiler le projet
1. Compilez le projet sur le serveur Maven par vous-même
Utilisez Git pour cloner le projet
$ git clone https://github.com/souyunku/other-projects.git
Utilisez Maven pour compiler le projet
$ cd autres projets / docker-spring-boot-demo /
2. Modifier le projet
Modifiez l'adresse du serveur Redis Spring.redis.host = 45.32.44.217 pour être l'IP local. Lors de l'exécution de l'image redis, Redis a été transformé en un service réseau externe 0.0.0.0:6379->6379/tcp
$ VI SRC / Main / Resources / Application.Properties # Redis Server Address Spring.redis.host = 45.32.44.217 $ Package MVN
Copiez le projet Docker-Spring-Boot-Demo-0.0.1-Snapshot.jar dans le répertoire cible / répertoire du / opt et sera utilisé plus tard
$ CP Target / docker-spring-boot-demo-0.0.1-snapshot.jar / opt /
2. Compilez le projet dans Maven local et téléchargez-le dans le répertoire / opt et sera utilisé plus tard
Modifiez l'adresse du serveur Redis de l'application.properties
d'autres projets / docker-spring-boot-demo / src / main / ressources / application.properties # redis server adresse Spring.redis.host = 45.32.44.217
5. Écrivez dockerfile
Écrire dockerfile basé sur Java: 8 image
$ cd / opt / $ touch dockerfile $ vi dockerfile
Le contenu édité est le suivant
# Basé sur l'image de Java: 8 # Montez le dossier local au volume de conteneur actuel / TMP # Copiez le fichier dans le conteneur, ou écrivez-le directement en tant qu'ajout de docker-spring-boot-demo-0.0.1-snapshot.jar /souyunku-app.jaradd docker-sounku-po- 0.0.1-snapshot.jar souyuku-jar 'Touch /souyunku-app.jar'# Ouvrir 80 Port Expose 80 # Configurez le point d'entrée de commande après le démarrage du conteneur ["java", "- djava.security.egd = file: / dev /./ urandom", "- jar", "/ souyunku-app.jar"]
Vi. Publier le projet
1. Compiler l'image
$ cd / opt / $ docker build -t souyunku-app: v1.
Voir les informations suivantes prouve que votre dockerfile n'est pas mauvais, et l'image a été compilée avec succès
Envoi du contexte de construction à Docker Daemon 18.72MBstep 1/6: De Java: 88: Tirer de la bibliothèque / Java5040BD298390: Pull complet FCE5728AAD85: Pull complet 76610EC20BF5 49E2D6393F32: Pull complet BB9CDEC9C7F3: Pull Complete Digest: Sha256: C1ff613E8BA25833D2E1940DA0940C3824F03F802C449F3D1815A66B7F8C0E9DSTATU D23BDF5B1B1BSTEP 2/6: Volume / TMP ---> EXAcéd dans 0559A62B0CD5Removing Intermediate Container 0559A62B0CD5 ---> B1F3846913A4STEP 3/6: Add docker-Spring-Boot-Demo-0.0.1 ---> 9f60dad5d2acstep 4/6: Run bash -c 'touch /souyunku-app.jar' ---> exécuté en 39d5c09ab614removing Intermediate Container 39d5c09ab614 ---> 2B691Adf7922Sp 5/6: Expose 80 ---> conteneur intermédiaire 11a577437a23 ---> 78815d6fe6b2step 6/6: entrée ["java", "- djava.security.egd = fichier: / dev /./ urandom", "- jar", "/ souyunku-app.jar"] ---> exécution dans eca10fed3d02removing intermenera ECA10FED3D02 ---> 8EC4E85A0F05 BESSUITSEMENT 8EC4E85A0F05 Tagged Souyunku-App: V1
2. Afficher le miroir
root @ suyunku: / opt # images docker Souyunku-appository tag ID d'image créé sizeyunku-app v1 8ec4e85a0f05 il y a 2 minutes 681MB
3. Exécutez le miroir
Le démon d'arrière-plan s'exécute, puis mappe le port de conteneur vers le port réseau externe 80
root @ souyunku: / opt # docker run --name myspringboot -d -p 80:80 souyunku-app: v1e68d438603619e363883d4eae65d3918e1c3e00f867731207bccf06f5690dc64
4. Afficher le processus
Vérifiez le processus de conteneur et vous pouvez voir que Redis est sur le port 6379 et que le projet MySpringBoot est sur le port 80.
root @ Souyunku: / opt # docker conteneur pscontainer id de commande d'image créé ports d'état namese68d43860361 Souyunku-app: v1 "java -djava.securit ..." il y a environ une minute en haut d'une minute 0.0.0.0:80->80/tcp Myspringboot0f9646171edd Redis Redis "Docker-Entrypoint.s ..." il y a 39 minutes en hausse 39 minutes 0.0.0.0:6379->6379/tcp redis-6379
7. Service de test
Accès du navigateur: http://127.0.0.1/, bien sûr, je ne suis pas entré 127.0.0.1 Je l'ai fait directement sur le serveur et j'ai utilisé l'IP publique
Docker
Docker Compose est l'un des projets officiels d'orchestration de Docker, responsable du déploiement rapidement des applications distribuées en grappes.
Une application qui utilise un conteneur Docker se compose généralement de plusieurs conteneurs. Avec Docker Compose , vous n'avez plus besoin d'utiliser des scripts shell pour démarrer les conteneurs. Dans le fichier de configuration, tous les conteneurs sont définis par les services, puis utilisent le script Docker-Compose pour démarrer, arrêter et redémarrer l'application, ainsi que les services de l'application et tous les conteneurs qui dépendent des services.
Résumer
Ce qui précède est l'exemple de code pour le projet Springboot de déploiement Docker que l'éditeur vous a introduit. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!