Ipinapatupad namin ang pag-deploy ng application - "Java project from A to Z"

Kamusta kayong lahat. Ipinagpapatuloy namin ang serye ng mga artikulo sa pagsulat ng iyong proyekto.

Pagbukud-bukurin ang mga sanga

Sa kahalagahan, upang hindi mawala sa mga sangay at ang kanilang pagkakasunud-sunod sa imbakan, nagpasya akong palitan ang pangalan ng mga ito sa pamamagitan ng pagdaragdag ng STEP_{number} prefix . Halimbawa, mayroon kaming tatlong sangay bilang karagdagan sa pangunahing isa:

• JRTB-0
• JRTB-2
• JRTB-3

Hindi mo agad mauunawaan kung alin ang dapat sundin pagkatapos nito. Kaya't papalitan ko ang pangalan ng mga ito bilang sumusunod:

• STEP_1_JRTB-0 - unang hakbang
• STEP_2_JRTB-2 - pangalawang hakbang
• STEP_3_JRTB-3 - ikatlong hakbang

At iba pa para sa mga susunod na artikulo. Upang palitan ang pangalan ng mga sangay, pumunta sa pahina ng repositoryo , hanapin ang kahon ng mga sanga , sundin ito: Sa ilalim ng bawat sangay, mag-click sa lapis at palitan ang pangalan ng sangay: At bilang isang resulta ay nakukuha namin: Siya nga pala, lahat ng nag-subscribe sa aking telegrama channel ay natagpuan out kaagad na pinangalanan ko ang mga sanga.

Kaunti tungkol sa Docker

Ano ang Docker? Sa madaling salita, ito ay isang tool kung saan maaari mong mabilis at ligtas na mag-deploy (mag-deploy) ng mga application, na lumilikha para sa kanila ng isang saradong imprastraktura na kinakailangan lamang para sa kanila. Mahirap pa rin, naiintindihan ko. Sa pangkalahatan, mauunawaan ang Docker bilang isang platform ng pag-unlad kung saan maaari kang magtrabaho nang mabilis at mahusay. Ang Docker ay maaaring maunawaan bilang isang programa na tumatakbo sa isang server. Ang program na ito ay may kakayahang mag-imbak ng mga lalagyan na may mga application. Ano ang lalagyan? Ito ay isang hiwalay na imprastraktura kung saan maaari mong idagdag ang lahat ng kailangan mo. Halimbawa, para sa isang Java application kailangan namin ng JRE para patakbuhin ang application, ang lalagyan ay magkakaroon nito, kakailanganin namin ng iba pang software - maaari naming idagdag ito. O baka kailangan natin ng Linux at isang Tomcat servlet container. Maaari rin itong gawin. Ang mga lalagyan ay nilikha batay sa isang imahe: iyon ay, ito ay isang partikular na template na naglalaman ng lahat ng kailangan upang lumikha ng isang Docker container. Paano lumikha ng larawang ito? Sa aming kaso, kakailanganin naming lumikha ng Dockerfile sa ugat ng proyekto na naglalarawan kung ano ang dapat na nasa lalagyan. Dahil ayaw naming ilantad ang token ng bot kahit saan, kailangan naming ipasa ito sa tuwing gusto naming i-deploy ang application. Maaari kang magbasa nang higit pa tungkol sa paksang ito dito at dito .

Nagsusulat kami ng JRTB-13

Kailangan naming mag-set up ng mabilis at madaling proseso ng pag-deploy para sa aming aplikasyon sa server. Iyon ay, para sa isang makina na gumagana 24/7. Gawin natin ang Docker bilang batayan. Ngunit walang gawain sa aming listahan na magiging responsable para sa pagdaragdag ng pagpapaandar na ito. Kahit papaano ay na-miss ko ito noong nilikha ko ito. Walang problema, gawin natin ito ngayon. Pumunta kami sa tab ng paggawa ng isyu sa GitHub at piliin ang Kahilingan sa Tampok: Magdagdag ng paglalarawan ng gawain, pamantayan para sa pagtanggap nito, itakda kung saang proyekto kabilang ang isyung ito at maaari kang lumikha ng bagong isyu: Ngayon, upang ipakita na ang gawain ay naging tinanggap para sa trabaho, baguhin ang katayuan ng gawain mula sa Gagawin sa Kasalukuyang Isinasagawa: Ito ay magiging isang mahirap na artikulo. Kung mayroon kang anumang mga problema, sumulat sa mga komento: Susubaybayan at sasagutin ko ang mga ito sa abot ng aking makakaya. Ito ay magiging isang maliit na Customer Support :D

Paglikha ng Dockerfile

Ano ang isang dockerfile? Para sa Docker, ito ay isang script (step-by-step na mga tagubilin) ​​kung paano gumawa ng imahe para sa isang Docker container. Para gumana ang aming aplikasyon, kailangan namin ang JDK, na bersyon 11 noon. Ibig sabihin, kailangan nating hanapin ang JDK 11 docker image at idagdag ito sa ating larawan. Ito ay isang bagay na katulad ng kung paano namin idagdag ang isang dependency sa isang memorya. Ang Docker ay mayroong DockerHub para sa layuning ito . Upang mag-download ng mga larawan nang lokal, kailangan mong magrehistro doon. Pagkatapos ng pagpaparehistro, hanapin natin ang JDK11. Mula sa nahanap ko, ito ang lalagyan: adoptopenjdk/openjdk11 . Ang paglalarawan ng container na ito ay mayroong kung ano ang kailangan para sa dockerfile:

FROM adoptopenjdk/openjdk11:ubi
RUN mkdir /opt/app
COPY japp.jar /opt/app
CMD ["java", "-jar", "/opt/app/japp.jar"]

Ayusin natin ang folder kung saan kinukuha natin ang jar file. Mayroon kami nito sa target na folder pagkatapos naming patakbuhin ang mvn package maven task. Bago gawin ang lahat ng ito, batay sa na-update na pangunahing sangay, lumikha kami ng bago para sa aming gawain: STEP_4_JRTB-13 . Ngayon ay maaari kang magtrabaho. Sa ugat ng proyekto, lumikha ng isang file nang walang extension ng Dockerfile at idagdag ang sumusunod sa loob:

FROM adoptopenjdk/openjdk11:ubi
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Ang unang linya ay kung saan ibabatay ang imahe - adoptopenjdk/openjdk11. Ang pangalawang linya ay magdagdag ng argumento sa imaheng pinangalanang JAR_FILE, na matatagpuan sa target na folder. Bukod dito, ang kasalukuyang folder ay tinutukoy ng lokasyon ng Dockerfile. Ikatlong linya - kopyahin ang garapon ng aming proyekto sa imahe ng docker. Ang huling linya ay mahalagang naglalaman ng array na nilikha mula sa command sa terminal, na pinaghihiwalay ng espasyo. Ibig sabihin, sa huli ay isasagawa ang sumusunod: “java -jar /app.jar” Upang panatilihing sikreto ang bot token, kapag sinimulan ang lalagyan, kakailanganin nating magpasa ng dalawang variable - ang pangalan ng bot at ang token nito. Para magawa ito, magsusulat kami ng query na dapat maglunsad ng aming proyekto na may mga variable. At paano ito gagawin? Kailangan mong i-Google ito: narito ang unang link na may normal na paglalarawan. Ano ang gusto nating gawin? Mayroon kaming dalawang variable sa application.properties file na aming tinukoy doon:

• bot.username
• bot.token

Gusto kong magpatakbo ng isang docker container at ipasa ang aking halaga doon sa bawat oras upang walang makakita sa mga halagang ito. Alam ko na sa SpringBoot, ang mga variable ng kapaligiran na itinakda kapag inilunsad ang jar project ay mauuna sa mga nasa application.properties file. Upang magpasa ng variable sa isang kahilingan, kailangan mong idagdag ang sumusunod na construction: -D{variable name}=”{variable value}” . Hindi kami nagdaragdag ng mga kulot na brace ;) Makakatanggap kami ng kahilingan na maglulunsad ng aming aplikasyon na may mga paunang natukoy na halaga - ang pangalan at token ng bot: java -jar -Dbot.username=”test.javarush.community_bot” -Dbot. token=”dfgkdjfglkdjfglkdjfgk” *.jar Ngayon kailangan nating ipasa ang mga variable na ito sa loob ng docker container. Ito ay isang variable ng kapaligiran. Upang matiyak na sa hinaharap ang aming database ay gumagana nang maayos at walang problema sa aming aplikasyon, gagamitin namin ang docker-compose. Ito ay isang hiwalay na tool kung saan maaari mong ayusin ang trabaho, startup, at dependencies sa pagitan ng mga container. Sa madaling salita, ito ay isang add-on sa itaas ng Docker upang pamahalaan ang mga lalagyan ng isang imprastraktura. Dagdag pa, bago patakbuhin ang docker-compose, kailangan naming tiyakin na nakuha namin ang lahat ng mga pagbabago sa code mula sa server, binuo ang application at itinigil ang lumang bersyon. Para dito gagamit kami ng bash script. Wow... Mukhang mahirap ang lahat, sang-ayon ako. Ngunit ang pagtatrabaho sa pagse-set up ng pag-deploy ng application ay palaging isang nakakapagod at kumplikadong proseso. Samakatuwid, mayroon kaming isang magandang scheme:

1. Patakbuhin natin ang script ng bash.
2. Ang bash script ay nagpapatakbo ng docker-compose.
3. Ang Docker-compose ay naglulunsad ng isang docker container sa aming application.
4. Pinapatakbo ng Docker container ang aming application.

At ngayon kailangan nating tiyakin na ang dalawang variable - ang pangalan ng bot at ang token nito - ay pumunta mula sa punto 1 hanggang sa punto 4. At upang ang dalawang variable na ito ay magamit kapag inilunsad ang aming java application. Tayo ay mula sa dulo hanggang sa simula. Alam na natin kung anong utos ang kailangang isagawa upang simulan ang jarnik. Samakatuwid, iko-configure namin ang Dockerfile upang matutunan nitong tanggapin ang dalawang variable at ipasa ang mga ito sa kahilingan. Upang gawin ito, bawasan natin ang Dockerfile sa sumusunod na form:

FROM adoptopenjdk/openjdk11:ubi
ARG JAR_FILE=target/*.jar
ENV BOT_NAME=test.javarush_community_bot
ENV BOT_TOKEN=1375780501:AAE4A6Rz0BSnIGzeu896OjQnjzsMEG6_uso
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-Dbot.username=${BOT_NAME}", "-Dbot.token=${BOT_TOKEN}", "-jar", "/app.jar"]

Makikita mo na nagdagdag kami ng dalawang linya at na-update ang ENTRYPOINT. Mga linya:

ENV BOT_NAME=test.javarush_community_bot
ENV BOT_TOKEN=1375780501:AAE4A6Rz0BSnIGzeu896OjQnjzsMEG6_uso

magdeklara ng mga variable sa loob ng encoder file. Bilang default, mayroon silang tinukoy na halaga. Kung, kapag lumilikha ng isang imahe mula sa dockerfile na ito, ang mga variable ng kapaligiran na may ganitong mga pangalan ay naipasa, ang mga halaga ay magkakaiba. At sa ENTRYPOINT nagdagdag kami ng ilan pang elemento na magbabasa ng mga variable ng kapaligiran na ito:

"-Dbot.username=${BOT_NAME}", "-Dbot.token=${BOT_TOKEN}"

Dito makikita mo na sa loob ng linya, gamit ang ${} construct, ang mga value ng BOT_NAME at BOT_TOKEN ay ipapasa. Susunod, kailangan nating ituro kung paano tanggapin at ipasa ang mga variable na ito sa docker-compose.

Lumikha ng docker-compose.yml

Makabubuti para sa iyo na basahin ang tungkol sa format na YAML nang hiwalay, kung hindi, ang artikulo ay lumalaki nang mabilis. Para sa amin, isa lang itong paglalarawan ng mga variable ng uri ng .properties. Sa mga katangian lamang ito ay nakasulat sa pamamagitan ng isang tuldok, ngunit sa YAML ito ay ginagawa nang mas maganda. Halimbawa, ganito. Dalawang variable sa .properties: javarush.telegram.bot.name=ivan javarush.telegram.bot.token=pupkin Ngunit sa .yaml (kapareho ng .yml) ito ay magiging ganito:

javarush:
	telegram:
		bot:
		  name: ivan
		  token: pupkin

Ang pangalawang pagpipilian ay mas maganda at naiintindihan. Ang mga puwang ay dapat na eksakto tulad ng ipinahiwatig sa itaas. Isalin natin ang ating application.properties at application.yml kahit papaano. Una kailangan mong likhain ito. Sa ugat ng proyekto, lumikha ng isang file docker-compose.yml at isulat ang sumusunod doon:

version: '3.1'

services:
 jrtb:
   build:
     context: .
   environment:
     - BOT_NAME=${BOT_NAME}
     - BOT_TOKEN=${BOT_TOKEN}
   restart: always

Ang unang linya ay ang bersyon ng docker-compose. services: sinasabi na ang lahat ng sumusunod na linya pagkatapos nito (ililipat) ay tumutukoy sa mga serbisyo na aming kino-configure. Mayroon lamang kaming isa sa mga ito sa ngayon - isang java application na tinatawag na jrtb . At nasa ilalim na nito ang lahat ng mga setting nito. Halimbawa, build: context: . sabi na hahanapin natin ang Dockerfile sa parehong direktoryo ng docker-compose.yml. Ngunit ang environment: section ay magiging responsable para sa pagtiyak na ipapasa namin ang mga kinakailangang environment variable sa Dockerfile. Kung ano lang ang kailangan natin. Samakatuwid, ipinapasa namin ang mga variable sa ibaba. Hahanapin sila ng Docker-compose sa mga variable ng operating environment ng server. Idagdag natin sila sa script ng bash.

Paglikha ng mga script ng bash

Ang huling hakbang ay ang gumawa ng bash script. Lumikha ng isang file na tinatawag na start.sh sa ugat ng proyekto at isulat ang sumusunod doon:

#!/bin/bash

# Pull new changes
git pull

# Prepare Jar
mvn clean
mvn package

# Ensure, that docker-compose stopped
docker-compose stop

# Add environment variables
export BOT_NAME=$1
export BOT_TOKEN=$2

# Start new deployment
docker-compose up --build -d

Ang unang linya ay kailangan para sa lahat ng mga script ng bash: hindi ito gagana kung wala ito. At pagkatapos - isang hanay lamang ng mga utos sa terminal na kailangang isagawa. Nagdagdag ako ng mga komento sa bawat utos kaya dapat itong maging malinaw. Ang tanging gusto kong ipaliwanag ay kung ano ang ibig sabihin ng $1 at $2. Ito ang dalawang variable na ipapasa kapag inilunsad ang bash script. Gamit ang export command, idaragdag sila sa mga variable ng server at babasahin sa docker-compose. Gumagana ito para sa Ubuntu, malamang na hindi para sa Windows, ngunit hindi ako sigurado. Ngayon ay kailangan mong idagdag ang stop.sh script, na hihinto sa trabaho. Maglalaman ito ng ilang linya:

#!/bin/bash

# Ensure, that docker-compose stopped
docker-compose stop

# Ensure, that the old application won't be deployed again.
mvn clean

Dito namin itinigil ang docker-compose at nililinis ang project jarnik, na nakalatag sa paligid mula noong huling build. Ginagawa namin ito upang matiyak na tumpak na itinayong muli ang aming proyekto. May mga nauna, kaya nagdadagdag ako) Bilang resulta, napupunta kami sa 4 na bagong file:

• Dockerfile - isang file para sa paglikha ng isang imahe ng aming application;
• docker-compose.yml - isang file na may mga setting para sa kung paano namin ilulunsad ang aming mga lalagyan;
• start.sh - bash script para sa pag-deploy ng aming application;
• stop.sh ay isang bash script upang ihinto ang aming aplikasyon.

Ia-update din namin ang bersyon ng aming application mula 0.2.0-SNAPSHOT hanggang 0.3.0-SNAPSHOT. Magdagdag tayo ng paglalarawan ng bagong bersyon sa RELEASE_NOTES at bahagyang i-refactor kung ano ang naroon: At sa README magdaragdag kami ng bagong talata na naglalarawan kung paano i-deploy ang aming aplikasyon: Siyempre, lahat ay nakasulat sa Ingles. Gaya ng dati, sa aming bagong likhang sangay na STEP_4_JRTB-13 gumawa kami ng bagong commit na may pangalang: JRTB-13: ipatupad ang proseso ng deployment sa pamamagitan ng docker at itulak ito. Huminto ako sa paninirahan nang detalyado sa mga bagay na inilarawan ko na sa mga nakaraang artikulo. Hindi ko nakikita ang punto sa pag-uulit ng parehong bagay. Bukod dito, ang mga nakaisip nito at gumawa nito mismo ay hindi magkakaroon ng anumang mga katanungan. Ito ang pinag-uusapan ko kung paano gumawa ng bagong branch, kung paano gumawa ng commit, kung paano mag-push ng commit sa repository.

Bottom line

Ngayon ay nagpakita ako ng isang toneladang bagong impormasyon na kailangang maingat na isaalang-alang at palawakin sa karagdagang pagbabasa. Ang pinakamahalagang bagay: sa tulong ng ONE (!!!) command, lahat ng kailangan para i-deploy ang aming application ay gagawin. Ito ay sobrang cool na hindi ko masabi sa iyo. Oo, kailangan kong gumugol ng isang disenteng dami ng oras sa dokumentasyon ng Docker upang maunawaan kung paano ipasa nang tama ang mga variable. Mula ngayon, ang telegram bot ay palaging gagana sa pinakabagong bersyon ng pangunahing sangay. Link sa telegram bot. Ngayon ay walang mga link sa mga materyal na magandang basahin: ang responsibilidad ay nasa iyo. Kailangan mong matutong maghanap ng impormasyon. Halos kaagad na natutunan ng lahat ng nag-subscribe sa aking telegram channel ang tungkol sa pag-deploy ng bot. Mga kaibigan, gusto mo ba ang proyekto? Bigyan mo siya ng bituin ! Sa ganitong paraan ito ay magiging mas sikat at mas maraming tao ang matututo tungkol dito at matuto mula rito. Gaya ng dati, iminumungkahi kong magparehistro sa GitHub at sundin ang aking account upang sundan ang seryeng ito at ang iba ko pang mga proyektong pinagtatrabahuhan ko doon. Ngayon handa na kaming ikonekta ang database. Ang susunod na artikulo ay magiging mas mahaba at sa loob nito gagawin namin ang lahat ng kinakailangan upang gumana sa database. Ang lahat ng paglalarawan ay nasa JRTB-1 .

Ang isang listahan ng lahat ng mga materyales sa serye ay nasa simula ng artikulong ito.