🥇บทช่วยสอน Kubernetes ตอนที่ 1: แอปพลิเคชัน ไมโครเซอร์วิส และคอนเทนเนอร์

ตามคำขอของเรา Habr ได้สร้างศูนย์กลางขึ้นมา Kubernetes และเรายินดีที่จะเผยแพร่ครั้งแรกในนั้น ติดตาม!

Kubernetes เป็นเรื่องง่าย เหตุใดธนาคารจึงจ่ายเงินให้ฉันเป็นจำนวนมากเพื่อทำงานในด้านนี้ ในขณะที่ใครๆ ก็สามารถเชี่ยวชาญเทคโนโลยีนี้ได้ภายในเวลาเพียงไม่กี่ชั่วโมง

หากคุณสงสัยว่า Kubernetes สามารถเรียนรู้ได้เร็วขนาดนี้ ฉันขอแนะนำให้คุณลองทำด้วยตัวเอง กล่าวคือ เมื่อเชี่ยวชาญเนื้อหานี้แล้ว คุณจะสามารถเรียกใช้แอปพลิเคชันโดยใช้ไมโครเซอร์วิสในคลัสเตอร์ Kubernetes ได้ ฉันรับประกันสิ่งนี้ได้ เนื่องจากเป็นวิธีการเดียวกับที่ฉันใช้ที่นี่ในการสอนลูกค้าของเราถึงวิธีทำงานกับ Kubernetes อะไรทำให้คู่มือนี้แตกต่างจากคู่มืออื่น ๆ จริงๆแล้วมีหลายสิ่งหลายอย่าง ดังนั้น เนื้อหาเหล่านี้ส่วนใหญ่เริ่มต้นด้วยคำอธิบายของสิ่งง่ายๆ - แนวคิดของ Kubernetes และคุณลักษณะของคำสั่ง kubectl ผู้เขียนบทความเหล่านี้สันนิษฐานว่าผู้อ่านมีความคุ้นเคยกับการพัฒนาแอปพลิเคชัน ไมโครเซอร์วิส และคอนเทนเนอร์ Docker เราจะไปทางอื่น ก่อนอื่น เรามาพูดถึงวิธีเรียกใช้แอปพลิเคชันโดยใช้ไมโครเซอร์วิสบนคอมพิวเตอร์กันก่อน จากนั้นเราจะมาดูการสร้างคอนเทนเนอร์อิมเมจสำหรับไมโครเซอร์วิสแต่ละรายการ หลังจากนั้น เราจะทำความคุ้นเคยกับ Kubernetes และวิเคราะห์การปรับใช้แอปพลิเคชันตามไมโครเซอร์วิสในคลัสเตอร์ที่จัดการโดย Kubernetes

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

เพื่อไม่ให้เป็นการเสียเวลา มาทำงานและพูดคุยเกี่ยวกับแอปพลิเคชันที่เราจะใช้งานกันดีกว่า

แอพทดลอง

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

นี่คือลักษณะของหน้าต่างหลักของแอปพลิเคชันนี้

เว็บแอปพลิเคชันการวิเคราะห์ความรู้สึก

จากมุมมองทางเทคนิค แอปพลิเคชันประกอบด้วยไมโครเซอร์วิสสามรายการ ซึ่งแต่ละบริการจะแก้ไขชุดงานเฉพาะ:

SA-Frontend เป็นเว็บเซิร์ฟเวอร์ Nginx ที่ให้บริการไฟล์สแตติก React
SA-WebApp เป็นเว็บแอปพลิเคชันที่เขียนด้วยภาษา Java ที่จัดการคำขอจากส่วนหน้า
SA-Logic เป็นแอปพลิเคชัน Python ที่ทำการวิเคราะห์ความรู้สึกของข้อความ

สิ่งสำคัญคือต้องทราบว่าไมโครเซอร์วิสไม่ได้แยกออกจากกัน พวกเขาใช้แนวคิดเรื่อง "การแบ่งแยกหน้าที่" แต่ในขณะเดียวกันก็ต้องมีปฏิสัมพันธ์ซึ่งกันและกัน

การไหลของข้อมูลในแอปพลิเคชัน

ในแผนภาพด้านบน คุณสามารถดูลำดับเลขของระบบ ซึ่งแสดงการไหลของข้อมูลในแอปพลิเคชัน มาทำลายพวกเขากัน:

เบราว์เซอร์ขอไฟล์จากเซิร์ฟเวอร์ index.html (ซึ่งจะโหลดแพ็คเกจแอป React)
ผู้ใช้โต้ตอบกับแอปพลิเคชัน ซึ่งทำให้เกิดการเรียกไปยังแอปพลิเคชันเว็บตาม Spring
เว็บแอปพลิเคชันส่งต่อคำขอเพื่อแยกวิเคราะห์ข้อความไปยังแอปพลิเคชัน Python
แอปพลิเคชัน Python วิเคราะห์ความรู้สึกของข้อความและส่งกลับผลลัพธ์เป็นการตอบสนองต่อคำขอ
แอปพลิเคชัน Spring จะส่งการตอบกลับไปยังแอปพลิเคชัน React (ซึ่งจะแสดงผลลัพธ์ของข้อความที่แยกวิเคราะห์ไปยังผู้ใช้)

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

การรันแอปพลิเคชันโดยอิงตามไมโครเซอร์วิสบนเครื่องท้องถิ่น

เพื่อให้แอปพลิเคชันทำงานได้ เราจำเป็นต้องเริ่มไมโครเซอร์วิสทั้งสามตัว เริ่มจากสิ่งที่สวยที่สุดกันก่อน - แอปพลิเคชันส่วนหน้า

▍ตั้งค่า React เพื่อการพัฒนาท้องถิ่น

ในการรันแอปพลิเคชัน React คุณต้องติดตั้งเฟรมเวิร์ก Node.js และ NPM บนคอมพิวเตอร์ของคุณ หลังจากที่คุณติดตั้งทั้งหมดนี้แล้ว ให้ใช้เทอร์มินัลไปยังโฟลเดอร์โปรเจ็กต์ sa-frontend และรันคำสั่งต่อไปนี้:

npm install

โดยดำเนินการคำสั่งนี้ในโฟลเดอร์ node_modules การขึ้นต่อกันของแอปพลิเคชัน React จะถูกโหลด ซึ่งบันทึกจะอยู่ในไฟล์ package.json. หลังจากดาวน์โหลดการขึ้นต่อกันในโฟลเดอร์เดียวกันแล้ว ให้รันคำสั่งต่อไปนี้:

npm start

นั่นคือทั้งหมดที่ แอป React กำลังทำงานอยู่และสามารถเข้าถึงได้โดยไปที่ที่อยู่เบราว์เซอร์ localhost:3000. คุณสามารถเปลี่ยนแปลงบางอย่างในรหัสของเขาได้ คุณจะเห็นผลกระทบของการเปลี่ยนแปลงเหล่านี้ในเบราว์เซอร์ทันที สิ่งนี้เป็นไปได้ด้วยการเปลี่ยนโมดูลที่เรียกว่า "ร้อน" ด้วยเหตุนี้ การพัฒนาส่วนหน้าจึงกลายเป็นประสบการณ์ที่เรียบง่ายและสนุกสนาน

▍การเตรียมแอป React สำหรับการใช้งานจริง

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

ในการสร้างแอป React อีกครั้งโดยใช้เทอร์มินัล ให้ไปที่โฟลเดอร์ sa-frontend และรันคำสั่งต่อไปนี้:

npm run build

สิ่งนี้จะสร้างไดเร็กทอรีในโฟลเดอร์โปรเจ็กต์ build. มันจะมีไฟล์สแตติกทั้งหมดที่จำเป็นสำหรับแอปพลิเคชัน React ในการทำงาน

▍ให้บริการไฟล์คงที่ด้วย Nginx

ก่อนอื่นคุณต้องติดตั้งและรันเว็บเซิร์ฟเวอร์ Nginx ที่นี่ คุณสามารถดาวน์โหลดและค้นหาคำแนะนำในการติดตั้งและใช้งาน จากนั้นคุณจะต้องคัดลอกเนื้อหาของโฟลเดอร์ sa-frontend/build ไปยังโฟลเดอร์ [your_nginx_installation_dir]/html.

ด้วยวิธีการนี้ ไฟล์ที่สร้างขึ้นระหว่างการประกอบแอปพลิเคชัน React index.html จะมีจำหน่ายที่ [your_nginx_installation_dir]/html/index.html. นี่คือไฟล์ที่เซิร์ฟเวอร์ Nginx ปัญหาตามค่าเริ่มต้นเมื่อเข้าถึง เซิร์ฟเวอร์ได้รับการกำหนดค่าให้ฟังบนพอร์ต 80แต่คุณสามารถปรับแต่งได้ตามที่คุณต้องการโดยการแก้ไขไฟล์ [your_nginx_installation_dir]/conf/nginx.conf.

ตอนนี้เปิดเบราว์เซอร์ของคุณแล้วไปที่ localhost:80. คุณจะเห็นหน้าแอป React

แอปโต้ตอบที่ให้บริการโดยเซิร์ฟเวอร์ Nginx

หากคุณป้อนบางสิ่งในฟิลด์ Type your sentence และกดปุ่ม Send - จะไม่มีอะไรเกิดขึ้น แต่ถ้าคุณดูที่คอนโซล คุณจะเห็นข้อความแสดงข้อผิดพลาดที่นั่น เพื่อให้เข้าใจได้อย่างชัดเจนว่าข้อผิดพลาดเหล่านี้เกิดขึ้นที่ใด เราจะมาวิเคราะห์โค้ดของแอปพลิเคชันกัน

▍การวิเคราะห์โค้ดของแอปพลิเคชันส่วนหน้า

ดูจากโค้ดของไฟล์ App.jsเราจะเห็นว่าการคลิกที่ปุ่มนั้น Send เรียกเมธอด analyzeSentence(). รหัสสำหรับวิธีนี้แสดงไว้ด้านล่าง ในขณะเดียวกันให้ใส่ใจกับความจริงที่ว่าสำหรับแต่ละบรรทัดที่มีความคิดเห็นของแบบฟอร์ม # Номерมีคำอธิบายด้านล่างโค้ด ในทำนองเดียวกัน เราจะแยกส่วนรหัสอื่นๆ

analyzeSentence() {
    fetch('http://localhost:8080/sentiment', {  // #1
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
                       sentence: this.textField.getValue()})// #2
    })
        .then(response => response.json())
        .then(data => this.setState(data));  // #3
}

1. URL ที่สร้างคำขอ POST ที่อยู่นี้จะถือว่าเป็นแอปพลิเคชันที่รอคำขอดังกล่าว

2.เนื้อหาคำขอที่ส่งไปยังแอปพลิเคชัน นี่คือตัวอย่างเนื้อหาคำขอ:

{
    sentence: "I like yogobella!"
}

3.เมื่อได้รับการตอบกลับคำขอ สถานะของคอมโพเนนต์จะถูกอัพเดต สิ่งนี้ทำให้ส่วนประกอบแสดงผลอีกครั้ง หากเราได้รับข้อมูล (นั่นคือ ออบเจกต์ JSON ที่มีข้อมูลที่ป้อนและคะแนนข้อความที่คำนวณ) เราจะส่งออกส่วนประกอบ Polarityตราบใดที่เป็นไปตามเงื่อนไข นี่คือวิธีที่เราอธิบายส่วนประกอบ:

const polarityComponent = this.state.polarity !== undefined ?
    <Polarity sentence={this.state.sentence} 
              polarity={this.state.polarity}/> :
    null;

ดูเหมือนว่ารหัสจะทำงานได้ค่อนข้างดี มีอะไรผิดปกติที่นี่หรือไม่? หากคุณคิดว่าที่อยู่ที่แอปพลิเคชันพยายามส่งคำขอ POST ยังไม่มีอะไรที่สามารถยอมรับและดำเนินการตามคำขอนี้ได้ แสดงว่าคุณคิดถูกอย่างแน่นอน กล่าวคือเพื่อดำเนินการตามคำขอที่มาถึงที่อยู่ http://localhost:8080/sentimentเราจำเป็นต้องเรียกใช้เว็บแอปพลิเคชันโดยใช้ Spring

เราต้องการแอปพลิเคชัน Spring ที่สามารถรับคำขอ POST ได้

▍การตั้งค่าเว็บแอปพลิเคชันตาม Spring

ในการปรับใช้แอปพลิเคชัน Spring คุณต้องมี JDK8 และ Maven และตัวแปรสภาพแวดล้อมที่กำหนดค่าอย่างเหมาะสม หลังจากที่คุณติดตั้งทั้งหมดนี้แล้ว คุณสามารถทำงานในโครงการของเราต่อได้

▍บรรจุแอปพลิเคชันลงในไฟล์ jar

นำทางโดยใช้เทอร์มินัลไปยังโฟลเดอร์ sa-webapp และป้อนคำสั่งต่อไปนี้:

mvn install

หลังจากรันคำสั่งนี้ในโฟลเดอร์แล้ว sa-webapp ไดเรกทอรีจะถูกสร้างขึ้น target. นี่คือตำแหน่งที่แอปพลิเคชัน Java จะบรรจุอยู่ในไฟล์ jar ที่แสดงโดยไฟล์ sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍การเรียกใช้แอปพลิเคชัน Java

ไปที่โฟลเดอร์ target และเรียกใช้แอปพลิเคชันด้วยคำสั่งต่อไปนี้:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar

จะเกิดข้อผิดพลาดขณะดำเนินการคำสั่งนี้ เพื่อเริ่มแก้ไข เราสามารถแยกวิเคราะห์รายละเอียดข้อยกเว้นในข้อมูลการติดตามสแต็กได้:

Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"

สำหรับเราสิ่งที่สำคัญที่สุดในที่นี้คือการกล่าวถึงความเป็นไปไม่ได้ที่จะชี้แจงความหมาย sa.logic.api.url. มาวิเคราะห์โค้ดที่เกิดข้อผิดพลาดกัน

▍การวิเคราะห์โค้ดแอปพลิเคชัน Java

นี่คือข้อมูลโค้ดที่เกิดข้อผิดพลาด

@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
    @Value("${sa.logic.api.url}")    // #1
    private String saLogicApiUrl;
    @PostMapping("/sentiment")
    public SentimentDto sentimentAnalysis(
        @RequestBody SentenceDto sentenceDto) 
    {
        RestTemplate restTemplate = new RestTemplate();
        return restTemplate.postForEntity(
                saLogicApiUrl + "/analyse/sentiment",    // #2
                sentenceDto, SentimentDto.class)
                .getBody();
    }
}

ในสentimentController มีสนามอยู่ saLogicApiUrl. มูลค่าของมันถูกกำหนดโดยคุณสมบัติ sa.logic.api.url.
เส้น saLogicApiUrl เชื่อมโยงกับคุณค่า /analyse/sentiment. พวกเขาร่วมกันสร้างที่อยู่สำหรับการโทรไปยังไมโครเซอร์วิสที่ทำการวิเคราะห์ข้อความ

▍การตั้งค่าคุณสมบัติ

ใน Spring แหล่งที่มาเริ่มต้นของค่าคุณสมบัติคือไฟล์ application.propertiesซึ่งสามารถพบได้ที่ sa-webapp/src/main/resources. แต่การใช้ไม่ใช่วิธีเดียวในการกำหนดค่าคุณสมบัติ คุณสามารถทำได้ด้วยคำสั่งต่อไปนี้:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URL

ค่าของคุณสมบัตินี้ควรชี้ไปยังที่อยู่ของแอปพลิเคชัน Python ของเรา

ด้วยการกำหนดค่า เราจะแจ้งให้เว็บแอปพลิเคชัน Spring ทราบว่าต้องไปที่ใดเพื่อดำเนินการคำขอแยกวิเคราะห์ข้อความ

เพื่อไม่ให้ชีวิตของเรายุ่งยากเราจะตัดสินใจว่าแอปพลิเคชัน Python จะพร้อมใช้งานที่ localhost:5000 และพยายามไม่ลืมมัน ด้วยเหตุนี้ คำสั่งในการเริ่มแอปพลิเคชัน Spring จะมีลักษณะดังนี้:

java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000

ระบบของเราไม่มีแอปพลิเคชัน Python

ตอนนี้เราต้องเรียกใช้แอปพลิเคชัน Python และระบบจะทำงานตามที่คาดไว้

▍การตั้งค่าแอปพลิเคชัน Python

ในการเรียกใช้แอปพลิเคชัน Python คุณต้องติดตั้ง Python 3 และ Pip และคุณต้องตั้งค่าตัวแปรสภาพแวดล้อมที่เหมาะสมอย่างถูกต้อง

▍ติดตั้งการพึ่งพา

ไปที่โฟลเดอร์โครงการ sa-logic/sa และเรียกใช้คำสั่งต่อไปนี้:

python -m pip install -r requirements.txt
python -m textblob.download_corpora

▍เปิดตัวแอป

เมื่อติดตั้งการพึ่งพาแล้ว เราก็พร้อมที่จะรันแอปพลิเคชัน:

python sentiment_analysis.py

หลังจากดำเนินการคำสั่งนี้ เราจะแจ้งดังต่อไปนี้:

* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

ซึ่งหมายความว่าแอปพลิเคชันกำลังทำงานและรอคำขอที่ localhost:5000/

▍การวิจัยโค้ด

มาดูโค้ดแอปพลิเคชัน Python เพื่อทำความเข้าใจว่ามันตอบสนองต่อคำขออย่างไร:

from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__)                                   #1
@app.route("/analyse/sentiment", methods=['POST'])      #2
def analyse_sentiment():
    sentence = request.get_json()['sentence']           #3
    polarity = TextBlob(sentence).sentences[0].polarity #4
    return jsonify(                                     #5
        sentence=sentence,
        polarity=polarity
    )
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)                #6

การเริ่มต้นวัตถุ Flask.
การระบุที่อยู่สำหรับการร้องขอ POST
การเรียกคืนทรัพย์สิน sentence จากเนื้อหาคำขอ
การเริ่มต้นวัตถุที่ไม่ระบุชื่อ TextBlob และได้รับคุณค่า polarity สำหรับข้อเสนอแรกที่ได้รับในเนื้อหาของคำขอ (ในกรณีของเรา นี่เป็นข้อเสนอเดียวที่ส่งมาเพื่อการวิเคราะห์)
การตอบกลับ โดยเนื้อหาประกอบด้วยข้อความของข้อเสนอและตัวบ่งชี้ที่คำนวณไว้ polarity.
เปิดตัวแอปพลิเคชั่น Flask ซึ่งจะวางจำหน่ายที่ 0.0.0.0:5000 (คุณสามารถเข้าถึงได้โดยใช้การสร้างแบบฟอร์ม localhost:5000).

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

ไมโครเซอร์วิสทั้งหมดที่ประกอบเป็นแอปพลิเคชันจะถูกทำให้มีสถานะสมบูรณ์

ก่อนที่เราจะดำเนินการต่อ ให้เปิดแอป React ในเบราว์เซอร์แล้วลองแยกวิเคราะห์ประโยคด้วย หากทุกอย่างถูกต้อง - หลังจากกดปุ่ม Send คุณจะเห็นผลการวิเคราะห์ด้านล่างกล่องข้อความ

ในส่วนถัดไป เราจะพูดถึงวิธีเรียกใช้ไมโครเซอร์วิสของเราในคอนเทนเนอร์ Docker นี่เป็นสิ่งจำเป็นเพื่อเตรียมแอปพลิเคชันให้ทำงานในคลัสเตอร์ Kubernetes

คอนเทนเนอร์นักเทียบท่า

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

คอนเทนเนอร์อิมเมจเป็นแพ็กเกจที่ปฏิบัติการได้และมีน้ำหนักเบา ครบถ้วนในตัวเอง ซึ่งประกอบด้วยแอปพลิเคชันซึ่งประกอบด้วยทุกสิ่งที่จำเป็นในการเรียกใช้: โค้ดแอปพลิเคชัน สภาพแวดล้อมรันไทม์ เครื่องมือระบบและไลบรารี การตั้งค่า โปรแกรมที่ใส่คอนเทนเนอร์สามารถใช้ได้ทั้งในสภาพแวดล้อม Linux และ Windows และจะทำงานเหมือนเดิมเสมอโดยไม่คำนึงถึงโครงสร้างพื้นฐาน

ซึ่งหมายความว่าคอนเทนเนอร์สามารถทำงานได้บนคอมพิวเตอร์เครื่องใดก็ได้ รวมถึงเซิร์ฟเวอร์ที่ใช้งานจริง และในสภาพแวดล้อมใดๆ แอปพลิเคชันที่อยู่ในนั้นก็จะทำงานในลักษณะเดียวกัน

หากต้องการสำรวจคุณสมบัติของคอนเทนเนอร์และเปรียบเทียบกับวิธีอื่นๆ ในการรันแอปพลิเคชัน มาดูตัวอย่างการให้บริการแอปพลิเคชัน React โดยใช้เครื่องเสมือนและคอนเทนเนอร์

▍การให้บริการไฟล์คงที่ของแอปพลิเคชัน React โดยใช้เครื่องเสมือน

พยายามจัดการบำรุงรักษาไฟล์คงที่โดยใช้เครื่องเสมือนเราจะพบข้อเสียดังต่อไปนี้:

การใช้ทรัพยากรอย่างไม่มีประสิทธิภาพ เนื่องจากเครื่องเสมือนแต่ละเครื่องเป็นระบบปฏิบัติการที่สมบูรณ์
การพึ่งพาแพลตฟอร์ม สิ่งที่ใช้งานได้บนเครื่องคอมพิวเตอร์บางเครื่องอาจไม่ทำงานบนเซิร์ฟเวอร์ที่ใช้งานจริง
การปรับขนาดโซลูชันเครื่องเสมือนที่ช้าและใช้ทรัพยากรมาก

เว็บเซิร์ฟเวอร์ Nginx ให้บริการไฟล์สแตติกที่ทำงานในเครื่องเสมือน

หากใช้คอนเทนเนอร์เพื่อแก้ไขปัญหาที่คล้ายกัน เมื่อเปรียบเทียบกับเครื่องเสมือน จุดแข็งต่อไปนี้สามารถสังเกตได้:

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

เว็บเซิร์ฟเวอร์ Nginx ที่ให้บริการไฟล์คงที่ที่ทำงานในคอนเทนเนอร์

เราได้เปรียบเทียบเครื่องเสมือนและคอนเทนเนอร์เพียงไม่กี่จุดเท่านั้น แต่นั่นก็เพียงพอแล้วที่จะเข้าใจถึงจุดแข็งของคอนเทนเนอร์ ที่นี่ คุณสามารถค้นหารายละเอียดเกี่ยวกับคอนเทนเนอร์ Docker

▍การสร้างอิมเมจคอนเทนเนอร์สำหรับแอป React

โครงสร้างพื้นฐานของคอนเทนเนอร์ Docker คือไฟล์ Dockerfile. ที่จุดเริ่มต้นของไฟล์นี้ อิมเมจพื้นฐานของคอนเทนเนอร์จะถูกบันทึก จากนั้นจะมีลำดับคำสั่งรวมอยู่ด้วยซึ่งระบุวิธีสร้างคอนเทนเนอร์ที่จะตอบสนองความต้องการของแอปพลิเคชัน

ก่อนที่เราจะเริ่มทำงานกับไฟล์ Dockerfileจำสิ่งที่เราทำเพื่อเตรียมไฟล์แอปพลิเคชัน React สำหรับการอัปโหลดไปยังเซิร์ฟเวอร์ Nginx:

การสร้างแพ็คเกจแอป React (npm run build).
การเริ่มต้นเซิร์ฟเวอร์ Nginx
การคัดลอกเนื้อหาของไดเร็กทอรี build จากโฟลเดอร์โครงการ sa-frontend ไปยังโฟลเดอร์เซิร์ฟเวอร์ nginx/html.

ด้านล่างนี้ คุณสามารถดูความคล้ายคลึงกันระหว่างการสร้างคอนเทนเนอร์และการกระทำข้างต้นที่ดำเนินการบนเครื่องคอมพิวเตอร์เฉพาะที่

▍การเตรียม Dockerfile สำหรับแอปพลิเคชัน SA-Frontend

คำแนะนำที่จะรวมอยู่ใน Dockerfile สำหรับการสมัคร SA-Frontendประกอบด้วยสองทีมเท่านั้น ความจริงก็คือทีมพัฒนา Nginx ได้เตรียมพื้นฐานไว้แล้ว ภาพ สำหรับ Nginx ซึ่งเราจะใช้สร้างอิมเมจของเรา ต่อไปนี้เป็นสองขั้นตอนที่เราต้องอธิบาย:

คุณต้องทำให้อิมเมจ Nginx เป็นพื้นฐานของรูปภาพ
เนื้อหาโฟลเดอร์ sa-frontend/build จำเป็นต้องคัดลอกไปยังโฟลเดอร์รูปภาพ nginx/html.

หากเราไปจากคำอธิบายนี้ไปยังไฟล์ Dockerfileแล้วจะมีลักษณะดังนี้:

FROM nginx
COPY build /usr/share/nginx/html

อย่างที่คุณเห็นทุกอย่างที่นี่เรียบง่ายมากในขณะที่เนื้อหาของไฟล์นั้นสามารถอ่านและเข้าใจได้ค่อนข้างมาก ไฟล์นี้บอกให้ระบบถ่ายภาพ nginx ด้วยทุกสิ่งที่มีอยู่แล้วและคัดลอกเนื้อหาของไดเร็กทอรี build ไปยังไดเร็กทอรี nginx/html.

ที่นี่คุณอาจมีคำถามเกี่ยวกับวิธีที่ฉันรู้ว่าจะคัดลอกไฟล์จากโฟลเดอร์ได้อย่างไร buildคือเส้นทางมาจากไหน /usr/share/nginx/html. ที่จริงแล้วไม่มีอะไรซับซ้อนที่นี่เช่นกัน ความจริงก็คือสามารถพบข้อมูลที่เกี่ยวข้องได้ใน คำอธิบาย ภาพ.

▍ประกอบภาพและอัปโหลดไปยังพื้นที่เก็บข้อมูล

ก่อนที่เราจะสามารถทำงานกับอิมเมจที่เสร็จสมบูรณ์ได้ เราต้องส่งมันไปยังที่เก็บอิมเมจเสียก่อน ในการดำเนินการนี้ เราจะใช้ Docker Hub แพลตฟอร์มโฮสต์รูปภาพบนคลาวด์ฟรี ในขั้นตอนการทำงานนี้ คุณต้องดำเนินการดังต่อไปนี้:

เพื่อทำการติดตั้ง นักเทียบท่า.
ลงทะเบียนบนเว็บไซต์ Docker Hub
เข้าสู่ระบบบัญชีของคุณโดยใช้คำสั่งต่อไปนี้ในเทอร์มินัล:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

ตอนนี้คุณต้องใช้เทอร์มินัลไปที่ไดเร็กทอรี sa-frontend และรันคำสั่งต่อไปนี้ที่นั่น:

docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .

ที่นี่และด้านล่างในคำสั่งที่คล้ายกัน $DOCKER_USER_ID ควรแทนที่ด้วยชื่อผู้ใช้ของคุณบน Docker Hub ตัวอย่างเช่น ส่วนนี้ของคำสั่งอาจมีลักษณะดังนี้: rinormaloku/sentiment-analysis-frontend.

ในกรณีนี้ คำสั่งนี้สามารถย่อให้สั้นลงได้โดยลบออก -f Dockerfileเนื่องจากโฟลเดอร์ที่เรารันคำสั่งนี้มีไฟล์นี้อยู่แล้ว

เพื่อส่งอิมเมจที่เสร็จแล้วไปยังที่เก็บ เราจำเป็นต้องมีคำสั่งต่อไปนี้:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

หลังจากเสร็จสิ้นแล้ว ให้ตรวจสอบรายการพื้นที่เก็บข้อมูลของคุณบน Docker Hub เพื่อดูว่าอิมเมจถูกพุชไปยังที่จัดเก็บข้อมูลบนคลาวด์สำเร็จหรือไม่

▍เริ่มสร้างคอนเทนเนอร์

ตอนนี้ใครๆ ก็สามารถดาวน์โหลดและเรียกใช้รูปภาพที่เรียกว่า $DOCKER_USER_ID/sentiment-analysis-frontend. ในการทำเช่นนี้ คุณต้องรันคำสั่งต่อไปนี้:

docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

ขณะนี้คอนเทนเนอร์กำลังทำงานอยู่ และเราสามารถทำงานต่อไปได้โดยการสร้างอิมเมจอื่นๆ ที่เราต้องการ แต่ก่อนที่จะไปต่อเรามาทำความเข้าใจการออกแบบกันก่อน 80:80ซึ่งพบได้ในคำสั่งให้รันอิมเมจและอาจดูสับสน

หมายเลขแรก 80 คือหมายเลขพอร์ตของโฮสต์ (นั่นคือ คอมพิวเตอร์ในระบบ)
ตัวที่สอง 80 คือพอร์ตของคอนเทนเนอร์ที่ควรเปลี่ยนเส้นทางคำขอ

พิจารณาภาพประกอบต่อไปนี้

การส่งต่อพอร์ต

ระบบจะส่งต่อคำขอจากพอร์ต <hostPort> ไปที่ท่าเรือ <containerPort>. นั่นคือการเข้าถึงพอร์ต 80 คอมพิวเตอร์ถูกเปลี่ยนเส้นทางไปยังพอร์ต 80 คอนเทนเนอร์.

ตั้งแต่ท่าเรือ 80 เปิดบนเครื่องคอมพิวเตอร์ คุณสามารถเข้าถึงแอปพลิเคชันจากคอมพิวเตอร์เครื่องนี้ได้ที่ localhost:80. หากระบบของคุณไม่รองรับ Docker คุณสามารถเรียกใช้แอปพลิเคชันบนเครื่องเสมือน Docker ซึ่งแอดเดรสจะมีลักษณะดังนี้ <docker-machine ip>:80. หากต้องการค้นหาที่อยู่ IP ของเครื่องเสมือน Docker คุณสามารถใช้คำสั่ง docker-machine ip.

ณ จุดนี้ เมื่อเปิดตัวคอนเทนเนอร์แอปส่วนหน้าสำเร็จแล้ว คุณควรจะสามารถเปิดหน้าคอนเทนเนอร์ในเบราว์เซอร์ได้

▍.ไฟล์ dockerignore

การสร้างอิมเมจแอปพลิเคชัน SA-Frontendเราจะสังเกตได้ว่ากระบวนการนี้ช้ามาก เนื่องจากบริบทการสร้างอิมเมจต้องถูกส่งไปยัง Docker daemon ไดเร็กทอรีที่แสดงถึงบริบทของ build ถูกกำหนดเป็นอาร์กิวเมนต์สุดท้ายของคำสั่ง docker build. ในกรณีของเรา มีจุดที่ท้ายคำสั่งนี้ ซึ่งส่งผลให้โครงสร้างต่อไปนี้ถูกรวมไว้ในบริบทแอสเซมบลี:

sa-frontend:
|   .dockerignore
|   Dockerfile
|   package.json
|   README.md
+---build
+---node_modules
+---public
---src

แต่ในบรรดาโฟลเดอร์ทั้งหมดที่นี่ เราต้องการเพียงโฟลเดอร์เท่านั้น build. การดาวน์โหลดสิ่งอื่นเป็นการเสียเวลา คุณสามารถเพิ่มความเร็วในการสร้างได้โดยบอก Docker ว่าไดเร็กทอรีใดที่จะเพิกเฉย เพื่อที่จะทำสิ่งนี้ เราจำเป็นต้องมีไฟล์ .dockerignore. คุณถ้าคุณคุ้นเคยกับไฟล์ .gitignoreโครงสร้างของไฟล์นี้อาจจะดูคุ้นเคย โดยแสดงรายการไดเร็กทอรีที่ระบบสร้างอิมเมจสามารถละเว้นได้ ในกรณีของเรา เนื้อหาของไฟล์นี้มีลักษณะดังนี้:

node_modules
src
public

ไฟล์ .dockerignore ต้องอยู่ในโฟลเดอร์เดียวกับไฟล์ Dockerfile. ตอนนี้การประกอบภาพจะใช้เวลาไม่กี่วินาที

ตอนนี้มาจัดการกับอิมเมจสำหรับแอปพลิเคชัน Java

▍สร้างอิมเมจคอนเทนเนอร์สำหรับแอปพลิเคชัน Java

คุณรู้อะไรไหม และคุณได้เรียนรู้ทุกสิ่งที่จำเป็นในการสร้างอิมเมจคอนเทนเนอร์แล้ว นั่นคือสาเหตุที่ส่วนนี้จะสั้นมาก

เปิดไฟล์ Dockerfileซึ่งอยู่ในโฟลเดอร์โปรเจ็กต์ sa-webapp. หากคุณอ่านข้อความของไฟล์นี้คุณจะพบเพียงสองโครงสร้างใหม่ที่ขึ้นต้นด้วยคำหลักเท่านั้น ENV и EXPOSE:

ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080

คำสำคัญ ENV ช่วยให้คุณสามารถประกาศตัวแปรสภาพแวดล้อมภายในคอนเทนเนอร์ Docker โดยเฉพาะอย่างยิ่งในกรณีของเรา ช่วยให้คุณสามารถตั้งค่า URL เพื่อเข้าถึง API ของแอปพลิเคชันที่ทำการวิเคราะห์ข้อความได้

คำสำคัญ EXPOSE อนุญาตให้คุณบอก Docker ให้เปิดพอร์ต เราจะใช้พอร์ตนี้ในขณะที่ทำงานกับแอปพลิเคชัน ที่นี่คุณสามารถเห็นได้ว่าใน Dockerfile สำหรับการสมัคร SA-Frontend ไม่มีคำสั่งดังกล่าว นี่เป็นเพื่อวัตถุประสงค์ในการจัดทำเอกสารเท่านั้น กล่าวอีกนัยหนึ่ง โครงสร้างนี้มีไว้สำหรับผู้อ่าน Dockerfile.

การสร้างอิมเมจและพุชไปยังที่เก็บดูเหมือนตัวอย่างก่อนหน้าทุกประการ หากคุณยังไม่มั่นใจในความสามารถของคุณ คุณสามารถพบคำสั่งที่เกี่ยวข้องได้ในไฟล์ README.md ในโฟลเดอร์ sa-webapp.

▍การสร้างคอนเทนเนอร์อิมเมจสำหรับแอปพลิเคชัน Python

หากคุณดูที่เนื้อหาของไฟล์ Dockerfile ในโฟลเดอร์ sa-logicคุณจะไม่พบสิ่งใหม่ที่นั่น คำสั่งสำหรับการสร้างอิมเมจและพุชไปยังพื้นที่เก็บข้อมูลน่าจะคุ้นเคยกับคุณอยู่แล้ว แต่ในกรณีของแอปพลิเคชันอื่นๆ ของเรา คำสั่งเหล่านี้สามารถพบได้ในไฟล์ README.md ในโฟลเดอร์ sa-logic.

▍การทดสอบแอปพลิเคชันแบบคอนเทนเนอร์

คุณสามารถเชื่อถือสิ่งที่คุณยังไม่ได้ทดสอบได้หรือไม่? ฉันก็ไม่สามารถเช่นกัน มาทดสอบคอนเทนเนอร์ของเรากัน

มาเริ่มคอนเทนเนอร์แอปพลิเคชันกันเลย sa-logic และกำหนดค่าให้ฟังบนพอร์ต 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
มาเริ่มคอนเทนเนอร์แอปพลิเคชันกันเลย sa-webapp และกำหนดค่าให้ฟังบนพอร์ต 8080. นอกจากนี้ เราจำเป็นต้องตั้งค่าพอร์ตที่แอปพลิเคชัน Python จะรับฟังคำขอจากแอปพลิเคชัน Java โดยการกำหนดตัวแปรสภาพแวดล้อมใหม่ SA_LOGIC_API_URL:
```
$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
```

หากต้องการเรียนรู้วิธีค้นหาที่อยู่ IP ของคอนเทนเนอร์หรือ Docker VM โปรดดูไฟล์ README.

มาเริ่มคอนเทนเนอร์แอปพลิเคชันกันเลย sa-frontend:

docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend

ตอนนี้ทุกอย่างพร้อมที่จะนำทางในเบราว์เซอร์ไปยังที่อยู่ localhost:80 และทดสอบแอป

โปรดทราบว่าหากคุณเปลี่ยนพอร์ตสำหรับ sa-webappหรือหากคุณใช้ Docker VM คุณจะต้องแก้ไขไฟล์ App.js จากโฟลเดอร์ sa-frontendโดยการเปลี่ยนที่อยู่ IP หรือหมายเลขพอร์ตในวิธีการ analyzeSentence()โดยการทดแทนข้อมูลปัจจุบันแทนข้อมูลที่ล้าสมัย หลังจากนั้นคุณจะต้องประกอบภาพอีกครั้งและใช้งาน

นี่คือลักษณะของแผนภาพแอปพลิเคชันของเราในขณะนี้

ไมโครเซอร์วิสทำงานในคอนเทนเนอร์

สรุป: เหตุใดเราจึงต้องมีคลัสเตอร์ Kubernetes

เราเพิ่งตรวจสอบไฟล์ Dockerfileพูดคุยเกี่ยวกับวิธีสร้างอิมเมจและพุชอิมเมจไปยังที่เก็บ Docker นอกจากนี้เรายังได้เรียนรู้วิธีเพิ่มความเร็วในการประกอบภาพโดยใช้ไฟล์อีกด้วย .dockerignore. ด้วยเหตุนี้ ไมโครเซอร์วิสของเราจึงทำงานในคอนเทนเนอร์ Docker ที่นี่คุณอาจมีคำถามที่สมเหตุสมผลว่าทำไมเราถึงต้องการ Kubernetes คำตอบสำหรับคำถามนี้จะเน้นไปที่ส่วนที่สองของเนื้อหานี้ ในระหว่างนี้ ให้พิจารณาคำถามต่อไปนี้:
สมมติว่าเว็บแอปพลิเคชันวิเคราะห์ข้อความของเราได้รับความนิยมไปทั่วโลก คำขอนับล้านมาหาเขาทุกนาที ซึ่งหมายความว่าไมโครเซอร์วิส sa-webapp и sa-logic จะอยู่ภายใต้ความเครียดอย่างมาก จะปรับขนาดคอนเทนเนอร์ที่รันไมโครเซอร์วิสได้อย่างไร

ที่มา: will.com

บทช่วยสอน Kubernetes ตอนที่ 1: แอปพลิเคชัน ไมโครเซอร์วิส และคอนเทนเนอร์