เราใช้การปรับใช้แอปพลิเคชัน - "โครงการ Java จาก A ถึง Z"

สวัสดีทุกคน. เราดำเนินการต่อชุดบทความเกี่ยวกับการเขียนโครงการของคุณ

จัดเรียงกิ่งก้าน

สิ่งสำคัญคือเพื่อไม่ให้หลงทางในกิ่งก้านและลำดับในที่เก็บ ฉันจึงตัดสินใจเปลี่ยนชื่อโดยเพิ่ม คำนำ หน้าSTEP_{number} ตัวอย่างเช่น เรามีสามสาขานอกเหนือจากสาขาหลัก:

• เจอาร์ทีบี-0
• เจอาร์ทีบี-2
• เจอาร์ทีบี-3

คุณจะไม่เข้าใจทันทีว่าอันไหนควรไปหลังจากนั้น ดังนั้นฉันจะเปลี่ยนชื่อดังต่อไปนี้:

• STEP_1_JRTB-0 - ขั้นตอนแรก
• STEP_2_JRTB-2 - ขั้นตอนที่สอง
• STEP_3_JRTB-3 - ขั้นตอนที่สาม

และสำหรับบทความถัดไป หากต้องการเปลี่ยนชื่อสาขาให้ไปที่หน้าพื้นที่เก็บข้อมูลค้นหา กล่อง สาขาติดตาม: ใต้แต่ละสาขา คลิกที่ดินสอแล้วเปลี่ยนชื่อสาขา: และผลลัพธ์ที่เราได้รับ: อย่างไรก็ตาม ทุกคนที่สมัครรับข้อมูลช่องโทรเลขของฉันพบ ออกมาทันทีว่าเปลี่ยนชื่อสาขาแล้ว

เล็กน้อยเกี่ยวกับด็อกเกอร์

นักเทียบท่าคืออะไร? กล่าวโดยสรุป มันเป็นเครื่องมือที่คุณสามารถปรับใช้ (ปรับใช้) แอปพลิเคชันได้อย่างรวดเร็วและปลอดภัย โดยสร้างโครงสร้างพื้นฐานแบบปิดที่จำเป็นสำหรับพวกเขาเท่านั้น มันยังยากอยู่ ฉันเข้าใจ โดยทั่วไปแล้ว Docker ถือเป็นแพลตฟอร์มการพัฒนาที่คุณสามารถทำงานได้อย่างรวดเร็วและมีประสิทธิภาพ Docker สามารถเข้าใจได้ว่าเป็นโปรแกรมที่ทำงานบนเซิร์ฟเวอร์ โปรแกรมนี้มีความสามารถในการจัดเก็บคอนเทนเนอร์พร้อมกับแอพพลิเคชั่น ภาชนะคืออะไร? นี่เป็นโครงสร้างพื้นฐานแยกต่างหากซึ่งคุณสามารถเพิ่มทุกสิ่งที่คุณต้องการได้ ตัวอย่างเช่น สำหรับแอปพลิเคชัน Java เราจำเป็นต้องมี JRE เพื่อรันแอปพลิเคชัน คอนเทนเนอร์จะมีสิ่งนี้ เราจำเป็นต้องมีซอฟต์แวร์อื่น - เราสามารถเพิ่มสิ่งนี้ได้ หรือบางทีเราต้องการ Linux และคอนเทนเนอร์เซิร์ฟเล็ต Tomcat ก็สามารถทำได้เช่นกัน คอนเทนเนอร์ถูกสร้างขึ้นตามรูปภาพ กล่าวคือ นี่คือเทมเพลตเฉพาะที่มีทุกสิ่งที่จำเป็นในการสร้างคอนเทนเนอร์ Docker จะสร้างภาพนี้ได้อย่างไร? ในกรณีของเรา เราจะต้องสร้าง Dockerfile ที่รากของโปรเจ็กต์เพื่ออธิบายสิ่งที่ควรอยู่ในคอนเทนเนอร์ เนื่องจากเราไม่ต้องการเปิดเผยโทเค็นของบอทไม่ว่าที่ใด เราจะต้องส่งต่อทุกครั้งที่เราต้องการปรับใช้แอปพลิเคชัน คุณสามารถอ่านเพิ่มเติมเกี่ยวกับหัวข้อนี้ได้ที่นี่และที่นี่

เราเขียน JRTB-13

เราจำเป็นต้องตั้งค่ากระบวนการปรับใช้ที่ง่ายและรวดเร็วสำหรับแอปพลิเคชันของเราไปยังเซิร์ฟเวอร์ นั่นก็คือสำหรับเครื่องจักรที่ทำงานตลอด 24 ชั่วโมงทุกวัน ลองใช้ Docker เป็นพื้นฐาน แต่ไม่มีงานใดในรายการของเราที่จะต้องรับผิดชอบในการเพิ่มฟังก์ชันนี้ อย่างใดฉันพลาดมันเมื่อสร้างมันขึ้นมา ไม่มีปัญหา เราจะสร้างมันขึ้นมาทันที ไปที่ แท็บ การสร้างปัญหาบน GitHub และเลือกคำขอคุณลักษณะ: เพิ่มคำอธิบายของงาน เกณฑ์สำหรับการยอมรับ กำหนดว่าปัญหานี้เป็นของโครงการใด และคุณสามารถสร้างปัญหาใหม่ได้: ตอนนี้ เพื่อแสดงว่างานได้รับการยอมรับ แล้ว สำหรับงานให้เปลี่ยนสถานะของงานจาก To do on In Progress: นี่คงเป็นบทความที่ยาก หากคุณมีปัญหาใด ๆ เขียนความคิดเห็น: ฉันจะตรวจสอบและตอบคำถามเหล่านี้อย่างสุดความสามารถ นี่จะเป็นการสนับสนุนลูกค้าเล็กๆ น้อยๆ :D

การสร้าง Dockerfile

ด็อคเกอร์ไฟล์คืออะไร? สำหรับ Docker นี่คือสคริปต์ (คำแนะนำทีละขั้นตอน) เกี่ยวกับวิธีการสร้างรูปภาพสำหรับคอนเทนเนอร์ Docker เพื่อให้แอปพลิเคชันของเราทำงานได้ เราจำเป็นต้องมี JDK เวอร์ชัน 11 นั่นคือเราต้องค้นหาอิมเมจนักเทียบท่า JDK 11 และเพิ่มลงในอิมเมจของเรา นี่เป็นสิ่งที่คล้ายกับวิธีที่เราเพิ่มการพึ่งพาให้กับหน่วยความจำ Docker มี DockerHubเพื่อจุดประสงค์นี้ หากต้องการดาวน์โหลดภาพในเครื่อง คุณต้องลงทะเบียนจากที่นั่น หลังจากลงทะเบียนแล้วไปหา JDK11 กัน จากสิ่งที่ ฉันพบ นี่คือคอนเทนเนอร์: adoptopenjdk/openjdk11 คำอธิบายของคอนเทนเนอร์นี้มีสิ่งที่จำเป็นสำหรับ dockerfile:

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

มาแก้ไขโฟลเดอร์ที่เรานำไฟล์ jar มา เรามีมันอยู่ในโฟลเดอร์เป้าหมายหลังจากที่เรารันงาน mvn package maven ก่อนที่จะทำทั้งหมดนี้ เราจะสร้างสาขาหลักใหม่สำหรับงานของเรา: STEP_4_JRTB-13 ตามสาขาหลักที่อัปเด ต ตอนนี้คุณสามารถทำงานได้ ในรูทของโปรเจ็กต์ ให้สร้างไฟล์ที่ไม่มี นามสกุล Dockerfileและเพิ่มไฟล์ต่อไปนี้เข้าไปภายใน:

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

บรรทัดแรกคือสิ่งที่รูปภาพจะใช้ - adoptopenjdk/openjdk11 บรรทัดที่สองคือการเพิ่มอาร์กิวเมนต์ให้กับรูปภาพชื่อ JAR_FILE ซึ่งอยู่ในโฟลเดอร์เป้าหมาย นอกจากนี้ โฟลเดอร์ปัจจุบันยังถูกกำหนดโดยตำแหน่งของ Dockerfile บรรทัดที่สาม - คัดลอก jar ของโปรเจ็กต์ของเราลงในอิมเมจนักเทียบท่า บรรทัดสุดท้ายประกอบด้วยอาร์เรย์ที่สร้างขึ้นจากคำสั่งในเทอร์มินัล ซึ่งถูกคั่นด้วยช่องว่าง นั่นคือในท้ายที่สุดสิ่งต่อไปนี้จะถูกดำเนินการ: “java -jar /app.jar” เพื่อรักษาโทเค็นโทเค็นของบอทไว้เป็นความลับ เมื่อเริ่มต้นคอนเทนเนอร์ เราจะต้องส่งผ่านตัวแปรสองตัว - ชื่อของบอทและโทเค็นของมัน เมื่อต้องการทำเช่นนี้ เราจะเขียนแบบสอบถามที่ควรเปิดโครงการของเราด้วยตัวแปร และจะทำอย่างไร? คุณต้องใช้ Google: นี่คือลิงค์แรกพร้อมคำอธิบายปกติ เราต้องการทำอะไร? เรามีตัวแปรสองตัวในไฟล์ application.properties ที่เรากำหนดไว้:

• bot.ชื่อผู้ใช้
• bot.โทเค็น

ฉันต้องการเรียกใช้คอนเทนเนอร์นักเทียบท่าและส่งค่าของฉันไปที่นั่นทุกครั้ง เพื่อไม่ให้ใครเห็นค่าเหล่านี้ ฉันรู้ว่าใน SpringBoot ตัวแปรสภาพแวดล้อมที่ตั้งค่าเมื่อเปิดตัวโปรเจ็กต์ jar จะมีความสำคัญเหนือกว่าตัวแปรในไฟล์ application.properties หากต้องการส่งตัวแปรในคำขอ คุณต้องเพิ่มโครงสร้างต่อไปนี้: -D{variable name}=”{variable value} ” เราไม่เพิ่มเครื่องหมายปีกกา ;) เราจะได้รับคำขอที่จะเปิดตัวแอปพลิเคชันของเราด้วยค่าที่กำหนดไว้ล่วงหน้า - ชื่อและโทเค็นของบอท: java -jar -Dbot.username=”test.javarush.community_bot” -Dbot token=”dfgkdjfglkdjfglkdjfgk” *.jar ตอนนี้เราต้องส่งตัวแปรเหล่านี้ไปภายในคอนเทนเนอร์นักเทียบท่า นี่คือตัวแปรสภาพแวดล้อม เพื่อให้แน่ใจว่าในอนาคตฐานข้อมูลของเราทำงานได้อย่างราบรื่นและไม่มีปัญหากับแอปพลิเคชันของเรา เราจะใช้ docker-compose นี่เป็นเครื่องมือแยกต่างหากที่คุณสามารถจัดระเบียบงาน การเริ่มต้น และการขึ้นต่อกันระหว่างคอนเทนเนอร์ได้ กล่าวอีกนัยหนึ่ง มันเป็นส่วนเสริมที่อยู่ด้านบนของ Docker เพื่อจัดการคอนเทนเนอร์ของโครงสร้างพื้นฐานเดียว นอกจากนี้ ก่อนที่จะรัน docker-compose เราต้องแน่ใจว่าเราได้ดึงการเปลี่ยนแปลงโค้ดทั้งหมดจากเซิร์ฟเวอร์ สร้างแอปพลิเคชัน และหยุดเวอร์ชันเก่าแล้ว สำหรับสิ่งนี้เราจะใช้สคริปต์ทุบตี ว้าว... ฟังดูยากนะ ฉันเห็นด้วย แต่การทำงานกับการตั้งค่าการใช้งานแอปพลิเคชันนั้นเป็นกระบวนการที่น่าเบื่อและซับซ้อนเสมอ ดังนั้นเราจึงมีโครงการที่ค่อนข้างดี:

1. มารันสคริปต์ทุบตีกัน
2. สคริปต์ทุบตีรันนักเทียบท่าเขียน
3. Docker-compose เปิดตัวคอนเทนเนอร์นักเทียบท่าด้วยแอปพลิเคชันของเรา
4. คอนเทนเนอร์ Docker รันแอปพลิเคชันของเรา

และตอนนี้เราต้องแน่ใจว่าตัวแปรสองตัว - ชื่อของบอทและโทเค็น - ไปจากจุดที่ 1 ไปยังจุดที่ 4 และเพื่อให้ตัวแปรทั้งสองนี้ถูกใช้เมื่อเปิดแอปพลิเคชัน java ของเรา ไปตั้งแต่ต้นจนจบกันเถอะ เรารู้แล้วว่าคำสั่งใดที่จำเป็นต้องดำเนินการเพื่อเริ่ม jarnik ดังนั้นเราจะกำหนดค่า Dockerfile เพื่อให้เรียนรู้ที่จะยอมรับตัวแปรสองตัวและส่งต่อไปยังคำขอ เมื่อต้องการทำเช่นนี้ ให้ลดขนาด Dockerfile เป็นรูปแบบต่อไปนี้:

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"]

คุณจะเห็นว่าเราได้เพิ่มสองบรรทัดและอัปเดต ENTRYPOINT เส้น:

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

ประกาศตัวแปรภายในไฟล์ตัวเข้ารหัส โดยค่าเริ่มต้นจะมีการระบุค่าไว้ หากเมื่อสร้างรูปภาพจาก dockerfile นี้ มีการส่งผ่านตัวแปรสภาพแวดล้อมที่มีชื่อดังกล่าว ค่าจะแตกต่างออกไป และใน ENTRYPOINT เราได้เพิ่มองค์ประกอบอีกสองสามรายการที่จะอ่านตัวแปรสภาพแวดล้อมเหล่านี้:

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

ที่นี่คุณจะเห็นว่าภายในบรรทัดโดยใช้โครงสร้าง ${} ค่าของ BOT_NAME และ BOT_TOKEN จะถูกส่งผ่าน ต่อไป เราต้องสอนวิธีรับและส่งตัวแปรเหล่านี้ไปยังนักเทียบท่าเขียน

สร้าง docker-compose.yml

คงจะดีถ้าคุณอ่านเกี่ยวกับรูปแบบ YAML แยกกัน ไม่เช่นนั้นบทความจะเติบโตอย่างก้าวกระโดดแล้ว สำหรับเรา นี่เป็นอีกคำอธิบายหนึ่งของตัวแปรประเภท .properties เฉพาะในคุณสมบัติเท่านั้นที่เขียนผ่านจุด แต่ใน YAML สิ่งนี้ทำได้สวยงามขึ้นอีกเล็กน้อย ตัวอย่างเช่นเช่นนี้ ตัวแปรสองตัวใน .properties: javarush.telegram.bot.name=ivan javarush.telegram.bot.token=pupkin แต่ใน .yaml (เหมือนกับ .yml) มันจะเป็นดังนี้:

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

ตัวเลือกที่สองสวยงามและเข้าใจได้มากขึ้น ช่องว่างควรตรงตามที่ระบุไว้ข้างต้นทุกประการ มาแปล application.properties และ application.yml ของเรากันดีกว่า ก่อนอื่นคุณต้องสร้างมันขึ้นมา ในรูทของโปรเจ็กต์ ให้สร้างไฟล์docker-compose.ymlและเขียนสิ่งต่อไปนี้ที่นั่น:

version: '3.1'

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

บรรทัดแรกคือเวอร์ชันที่เขียนโดยนักเทียบท่า บริการ:บอกว่าบรรทัดต่อไปนี้ทั้งหมดหลังจากนี้ (จะถูกเลื่อน) หมายถึงบริการที่เรากำลังกำหนดค่า จนถึงขณะนี้เรามีแอปพลิเคชัน Java ที่เรียกว่าjrtb เพียง รายการเดียวเท่านั้น และภายใต้นั้นจะเป็นการตั้งค่าทั้งหมด ตัวอย่างเช่นbuild: บริบท: . บอกว่าเราจะค้นหา Dockerfile ในไดเรกทอรีเดียวกันกับ docker-compose.yml แต่ ส่วน สภาพแวดล้อม:จะรับผิดชอบในการทำให้แน่ใจว่าเราส่งตัวแปรสภาพแวดล้อมที่จำเป็นไปยัง Dockerfile สิ่งที่เราต้องการ ดังนั้นเราจึงส่งตัวแปรด้านล่าง นักเทียบท่าเขียนจะค้นหาสิ่งเหล่านี้ในตัวแปรสภาพแวดล้อมการทำงานของเซิร์ฟเวอร์ มาเพิ่มลงในสคริปต์ทุบตี

การสร้างสคริปต์ทุบตี

ขั้นตอนสุดท้ายคือการสร้างสคริปต์ทุบตี สร้างไฟล์ชื่อ start.sh ในรูทของโปรเจ็กต์และเขียนไฟล์ต่อไปนี้:

#!/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

บรรทัดแรกจำเป็นสำหรับสคริปต์ทุบตีทั้งหมด: มันจะไม่ทำงานหากไม่มีมัน จากนั้น - เพียงชุดคำสั่งในเทอร์มินัลที่ต้องดำเนินการ ฉันได้เพิ่มความคิดเห็นในแต่ละคำสั่งดังนั้นจึงควรมีความชัดเจน สิ่งเดียวที่ฉันต้องการอธิบายคือความหมายของ $1 และ $2 นี่คือตัวแปรสองตัวที่จะถูกส่งไปเมื่อมีการเปิดใช้งานสคริปต์ทุบตี เมื่อใช้คำสั่งส่งออก พวกมันจะถูกเพิ่มลงในตัวแปรเซิร์ฟเวอร์และอ่านใน docker-compose สิ่งนี้ใช้ได้กับ Ubuntu อาจไม่ใช่สำหรับ Windows แต่ฉันไม่แน่ใจ ตอนนี้คุณต้องเพิ่มสคริปต์ stop.sh ซึ่งจะหยุดการทำงาน จะประกอบด้วยหลายบรรทัด:

#!/bin/bash

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

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

ที่นี่เราหยุดการเขียนนักเทียบท่าและทำความสะอาดโปรเจ็กต์ jarnik ซึ่งวางอยู่รอบ ๆ นับตั้งแต่การสร้างครั้งล่าสุด เราทำเช่นนี้เพื่อให้แน่ใจว่าโครงการของเราถูกสร้างขึ้นใหม่อย่างถูกต้อง มีแบบอย่างอยู่แล้ว นั่นคือเหตุผลที่ฉันเพิ่ม) ด้วยเหตุนี้ เราจึงได้ไฟล์ใหม่ 4 ไฟล์:

• Dockerfile - ไฟล์สำหรับสร้างรูปภาพแอปพลิเคชันของเรา
• docker-compose.yml - ไฟล์ที่มีการตั้งค่าว่าเราจะเปิดตัวคอนเทนเนอร์ของเราอย่างไร
• start.sh - สคริปต์ทุบตีสำหรับการปรับใช้แอปพลิเคชันของเรา
• stop.sh เป็นสคริปต์ทุบตีเพื่อหยุดแอปพลิเคชันของเรา

นอกจากนี้เรายังจะอัปเดตเวอร์ชันของแอปพลิเคชันของเราจาก 0.2.0-SNAPSHOT เป็น 0.3.0-SNAPSHOT มาเพิ่มคำอธิบายของเวอร์ชันใหม่ให้กับ RELEASE_NOTES และปรับโครงสร้างใหม่เล็กน้อยว่ามีอะไรบ้าง: และใน README เราจะเพิ่มย่อหน้าใหม่ที่อธิบายวิธีการปรับใช้แอปพลิเคชันของเรา: แน่นอนว่าทุกอย่างเขียนเป็นภาษาอังกฤษ ตามปกติในสาขา STEP_4_JRTB-13 ที่สร้างขึ้นใหม่ของเรา เราจะสร้างการคอมมิตใหม่โดยใช้ชื่อ: JRTB-13: ใช้กระบวนการปรับใช้ผ่านนักเทียบท่าและพุชมัน ฉันหยุดจมอยู่กับรายละเอียดเกี่ยวกับสิ่งที่ฉันได้อธิบายไปแล้วในบทความก่อนหน้านี้ ฉันไม่เห็นประเด็นในการทำซ้ำสิ่งเดียวกัน นอกจากนี้ผู้ที่คิดและลงมือทำเองจะไม่มีคำถามใดๆ ฉันพูดถึงวิธีสร้างสาขาใหม่ วิธีสร้างการคอมมิต วิธีส่งคอมมิตไปยังพื้นที่เก็บข้อมูล

บรรทัดล่าง

วันนี้ฉันได้แสดงข้อมูลใหม่มากมายที่ต้องพิจารณาอย่างรอบคอบและขยายเพิ่มเติมด้วยการอ่านเพิ่มเติม สิ่งที่สำคัญที่สุด: ด้วยความช่วยเหลือของคำสั่ง ONE (!!!) ทุกอย่างที่จำเป็นในการปรับใช้แอปพลิเคชันของเราก็จะเสร็จสิ้น มันเจ๋งมากจนฉันไม่สามารถบอกคุณได้ ใช่ ฉันต้องใช้เวลาพอสมควรในเอกสารประกอบของ Docker เพื่อทำความเข้าใจวิธีการส่งต่อตัวแปรอย่างถูกต้อง จากนี้ไป บอทโทรเลขจะทำงานบนเวอร์ชันล่าสุดของสาขา หลักเสมอ ลิงก์ไปยังบอทโทรเลข วันนี้จะไม่มีลิงก์ไปยังเนื้อหาที่น่าอ่าน: ความรับผิดชอบอยู่ที่คุณ คุณต้องเรียนรู้ที่จะค้นหาข้อมูล ทุกคนที่ติดตามช่องโทรเลขของฉันได้เรียนรู้เกี่ยวกับการปรับใช้บอทเกือบจะในทันที เพื่อนๆ คุณชอบโครงการนี้ไหม? ให้เขาดาว ! ด้วยวิธีนี้มันจะกลายเป็นที่นิยมมากขึ้นและผู้คนจะสามารถเรียนรู้และเรียนรู้จากมันได้มากขึ้น ตามปกติ ฉันขอแนะนำให้ลงทะเบียนบน GitHub และติดตามบัญชีของฉันเพื่อติดตามซีรี่ส์นี้และโปรเจ็กต์อื่น ๆ ของฉันที่ฉันทำที่นั่น ตอนนี้เราพร้อมที่จะเชื่อมต่อฐานข้อมูลแล้ว บทความถัดไปจะยาวขึ้นและเราจะทำทุกอย่างที่จำเป็นในการทำงานกับฐานข้อมูล คำอธิบายทั้งหมดอยู่ในJRTB- 1

รายการเนื้อหาทั้งหมดในซีรีส์นี้อยู่ที่ตอนต้นของบทความนี้