🥇Tutorial Kubernetes Bahagian 1: Aplikasi, Perkhidmatan Mikro dan Bekas

Atas permintaan kami, Habr mencipta hab Kubernetes dan kami berbesar hati untuk meletakkan penerbitan pertama di dalamnya. Langgan!

Kubernetes adalah mudah. Mengapakah bank membayar saya banyak wang untuk bekerja di kawasan ini, sedangkan sesiapa sahaja boleh menguasai teknologi ini dalam beberapa jam sahaja?

Jika anda meragui bahawa Kubernetes boleh dipelajari dengan begitu cepat, saya cadangkan anda cuba melakukannya sendiri. Iaitu, setelah menguasai bahan ini, anda akan dapat menjalankan aplikasi berdasarkan perkhidmatan mikro dalam kelompok Kubernetes. Saya boleh menjamin ini, kerana dalam metodologi yang sama yang saya gunakan di sini, saya mengajar pelanggan kami cara bekerja dengan Kubernetes. Apakah yang membezakan panduan ini daripada yang lain? Sebenarnya, banyak perkara. Oleh itu, kebanyakan bahan ini bermula dengan penjelasan tentang perkara mudah - konsep Kubernetes dan ciri arahan kubectl. Pengarang artikel ini menganggap bahawa pembaca mereka biasa dengan pembangunan aplikasi, perkhidmatan mikro dan bekas Docker. Kami akan pergi ke arah lain. Mula-mula, mari kita bincangkan tentang cara menjalankan aplikasi berdasarkan perkhidmatan mikro pada komputer. Kemudian kita akan melihat membina imej bekas untuk setiap perkhidmatan mikro. Dan selepas itu, kami akan berkenalan dengan Kubernetes dan menganalisis penggunaan aplikasi berdasarkan perkhidmatan mikro dalam kelompok yang diuruskan oleh Kubernetes.

Pendekatan ini, dengan pendekatan beransur-ansur kepada Kubernetes, akan memberikan pemahaman yang mendalam tentang apa yang berlaku yang diperlukan oleh orang biasa untuk memahami cara mudahnya segala-galanya diatur dalam Kubernetes. Kubernetes sememangnya teknologi yang mudah, dengan syarat sesiapa yang ingin menguasainya tahu di mana dan bagaimana ia digunakan.

Sekarang, tanpa berlengah lagi, mari kita mulakan dan bercakap tentang aplikasi yang akan kita usahakan.

Apl eksperimen

Aplikasi kami hanya akan melaksanakan satu fungsi. Ia mengambil, sebagai input, satu ayat, selepas itu, menggunakan alat analisis teks, ia melakukan analisis sentimen ayat ini, mendapatkan penilaian sikap emosi pengarang ayat terhadap objek tertentu.

Inilah rupa tetingkap utama aplikasi ini.

Aplikasi Web Analisis Sentimen

Dari sudut pandangan teknikal, aplikasi itu terdiri daripada tiga perkhidmatan mikro, setiap satunya menyelesaikan satu set tugas tertentu:

SA-Frontend ialah pelayan web Nginx yang menyediakan fail statik React.
SA-WebApp ialah aplikasi web yang ditulis dalam Java yang mengendalikan permintaan daripada bahagian hadapan.
SA-Logic ialah aplikasi Python yang menjalankan analisis sentimen teks.

Adalah penting untuk ambil perhatian bahawa perkhidmatan mikro tidak wujud secara berasingan. Mereka melaksanakan idea "pemisahan tugas", tetapi mereka, pada masa yang sama, perlu berinteraksi antara satu sama lain.

Aliran data dalam aplikasi

Dalam rajah di atas, anda boleh melihat peringkat bernombor sistem, menggambarkan aliran data dalam aplikasi. Mari pecahkan mereka:

Penyemak imbas meminta fail daripada pelayan index.html (yang seterusnya memuatkan pakej aplikasi React).
Pengguna berinteraksi dengan aplikasi, ini menyebabkan panggilan ke aplikasi web berdasarkan Spring.
Aplikasi web memajukan permintaan untuk menghuraikan teks ke aplikasi Python.
Aplikasi Python menganalisis sentimen teks dan mengembalikan hasilnya sebagai tindak balas kepada permintaan.
Aplikasi Spring menghantar respons kepada aplikasi React (yang seterusnya, menunjukkan hasil teks yang dihuraikan kepada pengguna).

Kod untuk semua aplikasi ini boleh didapati di sini. Saya mengesyorkan agar anda menyalin repositori ini kepada diri anda sekarang, kerana terdapat banyak percubaan menarik di hadapan kami dengannya.

Menjalankan aplikasi berasaskan perkhidmatan mikro pada mesin tempatan anda

Untuk membolehkan aplikasi berfungsi, kita perlu memulakan ketiga-tiga perkhidmatan mikro. Mari kita mulakan dengan yang paling cantik - aplikasi bahagian hadapan.

▍Sediakan React untuk pembangunan tempatan

Untuk menjalankan aplikasi React, anda perlu memasang rangka kerja Node.js dan NPM pada komputer anda. Selepas anda memasang semua ini, pergi menggunakan terminal ke folder projek sa-frontend dan jalankan arahan berikut:

npm install

Dengan melaksanakan arahan ini dalam folder node_modules kebergantungan aplikasi React akan dimuatkan, yang rekodnya ada dalam fail package.json. Selepas memuat turun dependensi dalam folder yang sama, jalankan arahan berikut:

npm start

Itu sahaja. Aplikasi React kini berjalan dan boleh diakses dengan menavigasi ke alamat penyemak imbas localhost:3000. Anda boleh menukar sesuatu dalam kodnya. Anda akan segera melihat kesan perubahan ini dalam penyemak imbas. Ini mungkin terima kasih kepada penggantian modul yang dipanggil "panas". Terima kasih kepada ini, pembangunan bahagian hadapan bertukar menjadi pengalaman yang mudah dan menyeronokkan.

▍Menyediakan apl React untuk pengeluaran

Untuk tujuan benar-benar menggunakan apl React, kami perlu menukarnya menjadi satu set fail statik dan menyampaikannya kepada pelanggan menggunakan pelayan web.

Untuk membina apl React, sekali lagi menggunakan terminal, navigasi ke folder sa-frontend dan jalankan arahan berikut:

npm run build

Ini akan mencipta direktori dalam folder projek build. Ia akan mengandungi semua fail statik yang diperlukan untuk aplikasi React berfungsi.

▍Menyajikan fail statik dengan Nginx

Mula-mula anda perlu memasang dan menjalankan pelayan web Nginx. ia adalah anda boleh memuat turunnya dan mencari arahan untuk memasang dan menjalankannya. Kemudian anda perlu menyalin kandungan folder sa-frontend/build ke folder [your_nginx_installation_dir]/html.

Dengan pendekatan ini, fail yang dijana semasa pemasangan aplikasi React index.html akan tersedia di [your_nginx_installation_dir]/html/index.html. Ini ialah fail yang, secara lalai, isu pelayan Nginx semasa mengaksesnya. Pelayan dikonfigurasikan untuk mendengar pada port 80, tetapi anda boleh menyesuaikannya dengan cara yang anda mahu dengan mengedit fail [your_nginx_installation_dir]/conf/nginx.conf.

Sekarang buka penyemak imbas anda dan pergi ke localhost:80. Anda akan melihat halaman apl React.

Apl React yang disediakan oleh pelayan Nginx

Jika anda kini memasukkan sesuatu dalam medan Type your sentence dan tekan butang Send - tiada apa yang akan berlaku. Tetapi, jika anda melihat konsol, anda boleh melihat mesej ralat di sana. Untuk memahami dengan tepat di mana ralat ini berlaku, mari analisa kod aplikasi.

▍Analisis kod aplikasi bahagian hadapan

Melihat kod fail App.js, kita dapat melihat bahawa mengklik pada butang Send memanggil kaedah analyzeSentence(). Kod untuk kaedah ini ditunjukkan di bawah. Pada masa yang sama, beri perhatian kepada fakta bahawa untuk setiap baris yang terdapat ulasan borang # Номер, terdapat penjelasan yang diberikan di bawah kod tersebut. Dengan cara yang sama, kami akan menghuraikan serpihan kod lain.

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 yang permintaan POST dibuat. Alamat ini diandaikan sebagai permohonan yang menunggu permintaan sedemikian.

2.Badan permintaan dihantar ke permohonan. Berikut ialah contoh badan permintaan:

{
    sentence: "I like yogobella!"
}

3.Apabila respons kepada permintaan diterima, keadaan komponen dikemas kini. Ini menyebabkan komponen itu dipaparkan semula. Jika kami menerima data (iaitu, objek JSON yang mengandungi data yang dimasukkan dan skor teks yang dikira), kami akan mengeluarkan komponen Polarityasalkan syarat dipenuhi. Inilah cara kami menerangkan komponen:

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

Kod itu nampaknya berfungsi dengan baik. Apa yang salah di sini? Jika anda menganggap bahawa di alamat yang permohonan itu cuba menghantar permintaan POST, belum ada apa-apa lagi yang boleh menerima dan memproses permintaan ini, maka anda akan betul. Iaitu, untuk memproses permintaan yang datang ke alamat http://localhost:8080/sentiment, kita perlu menjalankan aplikasi web berdasarkan Spring.

Kami memerlukan aplikasi Spring yang boleh menerima permintaan POST

▍Menyediakan aplikasi web berdasarkan Spring

Untuk menggunakan aplikasi Spring, anda memerlukan JDK8 dan Maven serta pembolehubah persekitaran yang dikonfigurasikan dengan betul. Selepas anda memasang semua ini, anda boleh terus mengerjakan projek kami.

▍Membungkus aplikasi ke dalam fail balang

Navigasi, menggunakan terminal, ke folder sa-webapp dan masukkan arahan berikut:

mvn install

Selepas melaksanakan arahan ini dalam folder sa-webapp direktori akan dibuat target. Di sinilah aplikasi Java akan ditempatkan, dibungkus dalam fail balang, diwakili oleh fail sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Melancarkan Aplikasi Java

Pergi ke folder target dan jalankan aplikasi dengan arahan berikut:

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

Ralat akan berlaku semasa melaksanakan arahan ini. Untuk mula membetulkannya, kami boleh menganalisis butiran pengecualian dalam data surih tindanan:

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

Bagi kami, perkara yang paling penting di sini ialah penyebutan kemustahilan untuk menjelaskan makna sa.logic.api.url. Mari analisa kod di mana ralat berlaku.

▍Analisis kod aplikasi Java

Berikut ialah coretan kod tempat ralat berlaku.

@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();
    }
}

Dalam SentimentController ada padang saLogicApiUrl. Nilainya ditetapkan oleh harta itu sa.logic.api.url.
Garisan saLogicApiUrl bercantum dengan nilai /analyse/sentiment. Bersama-sama mereka membentuk alamat untuk membuat panggilan ke perkhidmatan mikro yang menjalankan analisis teks.

▍Menetapkan nilai harta

Pada Musim Bunga, sumber lalai nilai harta adalah fail application.properties, yang boleh didapati di sa-webapp/src/main/resources. Tetapi menggunakannya bukan satu-satunya cara untuk menetapkan nilai harta. Anda juga boleh melakukan ini dengan arahan berikut:

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

Nilai harta ini harus menunjuk ke alamat aplikasi Python kami.

Dengan mengkonfigurasinya, kami memberitahu aplikasi web Spring ke mana ia perlu pergi untuk melaksanakan permintaan penghuraian teks.

Untuk tidak merumitkan kehidupan kami, kami akan memutuskan bahawa aplikasi Python akan tersedia di localhost:5000 dan cuba untuk tidak melupakannya. Akibatnya, arahan untuk memulakan aplikasi Spring akan kelihatan seperti ini:

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

Sistem kami tiada aplikasi Python

Sekarang kita hanya perlu menjalankan aplikasi Python dan sistem akan berfungsi seperti yang diharapkan.

▍Menyediakan aplikasi Python

Untuk menjalankan aplikasi Python, anda mesti memasang Python 3 dan Pip, dan anda mesti menetapkan pembolehubah persekitaran yang sesuai dengan betul.

▍Pasang kebergantungan

Pergi ke folder projek sa-logic/sa dan jalankan arahan berikut:

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

▍Pelancaran apl

Dengan kebergantungan dipasang, kami bersedia untuk menjalankan aplikasi:

python sentiment_analysis.py

Selepas melaksanakan arahan ini, kami akan diberitahu perkara berikut:

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

Ini bermakna aplikasi sedang berjalan dan menunggu permintaan di localhost:5000/

▍Penyelidikan kod

Mari lihat kod aplikasi Python untuk memahami cara ia bertindak balas kepada permintaan:

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

Inisialisasi objek Flask.
Menentukan alamat untuk membuat permintaan POST kepadanya.
Mendapatkan semula harta benda sentence daripada badan permintaan.
Inisialisasi objek tanpa nama TextBlob dan mendapat nilai polarity untuk ayat pertama yang diterima dalam badan permintaan (dalam kes kami, ini adalah satu-satunya ayat yang dihantar untuk analisis).
Mengembalikan respons, kandungan yang mengandungi teks tawaran dan penunjuk yang dikira untuknya polarity.
Melancarkan aplikasi Flask, yang boleh didapati di 0.0.0.0:5000 (anda juga boleh mengaksesnya menggunakan binaan borang localhost:5000).

Kini perkhidmatan mikro yang membentuk aplikasi sedang berjalan. Mereka bersedia untuk berinteraksi antara satu sama lain. Berikut ialah rupa rajah aplikasi pada peringkat kerja ini.

Semua perkhidmatan mikro yang membentuk aplikasi dibawa ke keadaan yang sihat

Sekarang, sebelum kita meneruskan, buka apl React dalam penyemak imbas dan cuba menghuraikan beberapa ayat dengannya. Jika semuanya dilakukan dengan betul - selepas menekan butang Send anda akan melihat hasil analisis di bawah kotak teks.

Dalam bahagian seterusnya, kita akan bercakap tentang cara menjalankan perkhidmatan mikro kami dalam bekas Docker. Ini adalah perlu untuk menyediakan aplikasi untuk dijalankan dalam kelompok Kubernetes.

Bekas berlabuh

Kubernetes ialah sistem untuk mengautomasikan penggunaan, penskalaan dan pengurusan aplikasi kontena. Ia juga dipanggil "pengatur kontena". Jika Kubernetes berfungsi dengan bekas, maka sebelum menggunakan sistem ini, kita perlu memperoleh bekas ini terlebih dahulu. Tetapi pertama, mari kita bercakap tentang bekas itu. Mungkin jawapan terbaik untuk soalan tentang apa itu boleh didapati dokumentasi kepada Docker:

Imej bekas ialah pakej ringan, serba lengkap, boleh laksana yang mengandungi aplikasi, yang merangkumi semua yang diperlukan untuk menjalankannya: kod aplikasi, persekitaran masa jalan, alatan sistem dan pustaka, tetapan. Program kontena boleh digunakan dalam kedua-dua persekitaran Linux dan Windows dan akan sentiasa berfungsi sama tanpa mengira infrastruktur.

Ini bermakna bekas boleh dijalankan pada mana-mana komputer, termasuk pelayan pengeluaran, dan dalam mana-mana persekitaran, aplikasi yang disertakan di dalamnya akan berfungsi dengan cara yang sama.

Untuk meneroka ciri bekas dan membandingkannya dengan cara lain untuk menjalankan aplikasi, mari lihat contoh menyediakan aplikasi React menggunakan mesin maya dan bekas.

▍Menyajikan fail statik aplikasi React menggunakan mesin maya

Cuba untuk mengatur penyelenggaraan fail statik menggunakan mesin maya, kami akan menghadapi kelemahan berikut:

Penggunaan sumber yang tidak cekap, kerana setiap mesin maya adalah sistem pengendalian yang lengkap.
Kebergantungan platform. Perkara yang berfungsi pada komputer tempatan tertentu mungkin tidak berfungsi pada pelayan pengeluaran.
Skala perlahan dan intensif sumber bagi penyelesaian mesin maya.

Pelayan web Nginx menyediakan fail statik yang berjalan dalam mesin maya

Jika bekas digunakan untuk menyelesaikan masalah yang sama, maka, berbanding dengan mesin maya, kekuatan berikut boleh diperhatikan:

Penggunaan sumber yang cekap: bekerja dengan sistem pengendalian menggunakan Docker.
Kemerdekaan platform. Bekas yang boleh dijalankan oleh pembangun pada komputer mereka sendiri akan dijalankan di mana-mana sahaja.
Penggunaan ringan melalui penggunaan lapisan imej.

Pelayan web Nginx menyediakan fail statik yang berjalan dalam bekas

Kami hanya membandingkan mesin maya dan bekas pada beberapa titik, tetapi itu pun sudah cukup untuk merasakan kekuatan kontena. ia adalah Anda boleh mendapatkan butiran tentang bekas Docker.

▍Membina imej bekas untuk apl React

Blok binaan asas bekas Docker ialah fail Dockerfile. Pada permulaan fail ini, imej asas bekas direkodkan, kemudian turutan arahan disertakan yang menunjukkan cara membuat bekas yang akan memenuhi keperluan aplikasi.

Sebelum kita mula bekerja dengan fail Dockerfile, ingat apa yang kami lakukan untuk menyediakan fail aplikasi React untuk dimuat naik ke pelayan Nginx:

Membina pakej aplikasi React (npm run build).
Memulakan pelayan Nginx.
Menyalin kandungan direktori build daripada folder projek sa-frontend ke folder pelayan nginx/html.

Di bawah anda boleh melihat persamaan antara mencipta bekas dan tindakan di atas yang dilakukan pada komputer tempatan.

▍Menyediakan Fail Docker untuk Aplikasi SA-Frontend

Arahan yang perlu disertakan dalam Dockerfile untuk permohonan SA-Frontend, terdiri daripada dua pasukan sahaja. Hakikatnya ialah pasukan pembangunan Nginx telah menyediakan asas imej untuk Nginx, yang akan kami gunakan untuk membina imej kami. Berikut ialah dua langkah yang perlu kita huraikan:

Anda perlu menjadikan imej Nginx sebagai asas imej.
Kandungan folder sa-frontend/build perlu salin ke folder imej nginx/html.

Jika kita pergi dari penerangan ini ke fail Dockerfile, maka ia akan kelihatan seperti ini:

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

Seperti yang anda lihat, segala-galanya di sini sangat mudah, dan kandungan fail itu ternyata agak mudah dibaca dan difahami. Fail ini memberitahu sistem untuk mengambil imej nginx dengan semua yang sudah ada, dan salin kandungan direktori build ke direktori nginx/html.

Di sini anda mungkin mempunyai soalan mengenai bagaimana saya tahu di mana betul-betul untuk menyalin fail dari folder build, iaitu dari mana datangnya jalan itu /usr/share/nginx/html. Malah, tidak ada yang rumit di sini sama ada. Hakikatnya ialah maklumat yang berkaitan boleh didapati di penerangan imej.

▍Mengumpul imej dan memuat naiknya ke repositori

Sebelum kita boleh bekerja dengan imej yang lengkap, kita perlu menyerahkannya ke repositori imej. Untuk melakukan ini, kami akan menggunakan platform pengehosan imej berasaskan awan percuma Docker Hub. Pada peringkat kerja ini, anda perlu melakukan perkara berikut:

Pasang buruh pelabuhan.
Daftar di tapak Docker Hub.
Log masuk ke akaun anda dengan menjalankan arahan berikut di terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Sekarang anda perlu, menggunakan terminal, pergi ke direktori sa-frontend dan jalankan arahan berikut di sana:

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

Di sini dan di bawah dalam arahan yang serupa $DOCKER_USER_ID hendaklah digantikan dengan nama pengguna anda di Docker Hub. Sebagai contoh, bahagian arahan ini mungkin kelihatan seperti ini: rinormaloku/sentiment-analysis-frontend.

Dalam kes ini, arahan ini boleh dipendekkan dengan mengalih keluar daripadanya -f Dockerfile, kerana folder di mana kita melaksanakan arahan ini sudah mempunyai fail ini.

Untuk menghantar imej siap ke repositori, kami memerlukan arahan berikut:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Selepas melengkapkannya, semak senarai repositori anda di Docker Hub untuk melihat sama ada imej itu berjaya ditolak ke storan awan.

▍Memulakan bekas

Kini sesiapa sahaja boleh memuat turun dan menjalankan imej yang dikenali sebagai $DOCKER_USER_ID/sentiment-analysis-frontend. Untuk melakukan ini, anda perlu menjalankan urutan arahan berikut:

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

Kini bekas sedang berjalan dan kami boleh terus bekerja dengan mencipta imej lain yang kami perlukan. Tetapi sebelum kita meneruskan, mari kita memahami reka bentuk 80:80, yang terdapat dalam arahan untuk menjalankan imej dan mungkin kelihatan mengelirukan.

Nombor pertama 80 ialah nombor port hos (iaitu, komputer tempatan).
Nombor kedua 80 ialah pelabuhan kontena yang permintaannya harus diubah hala.

Pertimbangkan ilustrasi berikut.

Port Forwarding

Sistem memajukan permintaan daripada pelabuhan <hostPort> ke pelabuhan <containerPort>. Iaitu, mengakses pelabuhan 80 komputer dialihkan ke port 80 bekas.

Sejak pelabuhan 80 dibuka pada komputer tempatan, anda boleh mengakses aplikasi daripada komputer ini di localhost:80. Jika sistem anda tidak menyokong Docker, anda boleh menjalankan aplikasi pada mesin maya Docker, alamatnya akan kelihatan seperti <docker-machine ip>:80. Untuk mengetahui alamat IP mesin maya Docker, anda boleh menggunakan arahan docker-machine ip.

Pada ketika ini, setelah bekas apl bahagian hadapan berjaya dilancarkan, anda sepatutnya boleh membuka halamannya dalam penyemak imbas.

▍.dockerignore fail

Membina imej aplikasi SA-Frontend, kita dapat melihat bahawa proses ini sangat perlahan. Ini kerana konteks binaan imej mesti dihantar kepada daemon Docker. Direktori yang mewakili konteks binaan diberikan sebagai hujah terakhir kepada arahan docker build. Dalam kes kami, terdapat titik di hujung arahan ini. Ini menyebabkan struktur berikut dimasukkan dalam konteks pemasangan:

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

Tetapi daripada semua folder yang ada di sini, kami hanya memerlukan folder build. Memuat turun apa-apa lagi adalah membuang masa. Anda boleh mempercepatkan binaan dengan memberitahu Docker direktori mana yang perlu diabaikan. Untuk melakukan ini, kami memerlukan fail .dockerignore. Anda, jika anda biasa dengan fail .gitignore, struktur fail ini mungkin kelihatan biasa. Ia menyenaraikan direktori yang boleh diabaikan oleh sistem binaan imej. Dalam kes kami, kandungan fail ini kelihatan seperti ini:

node_modules
src
public

fail .dockerignore mesti berada dalam folder yang sama dengan fail Dockerfile. Sekarang pemasangan imej akan mengambil masa beberapa saat.

Sekarang mari kita berurusan dengan imej untuk aplikasi Java.

▍Membina imej bekas untuk aplikasi Java

Anda tahu apa, dan anda telah mempelajari semua yang anda perlukan untuk membuat imej bekas. Itulah sebabnya bahagian ini akan menjadi sangat pendek.

Buka fail Dockerfile, yang terletak dalam folder projek sa-webapp. Jika anda membaca teks fail ini, maka di dalamnya anda akan menemui hanya dua binaan baharu yang bermula dengan kata kunci ENV и EXPOSE:

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

Kata kunci ENV membolehkan anda mengisytiharkan pembolehubah persekitaran di dalam bekas Docker. Khususnya, dalam kes kami, ia membolehkan anda menetapkan URL untuk mengakses API aplikasi yang menjalankan analisis teks.

Kata kunci EXPOSE membolehkan anda memberitahu Docker untuk membuka port. Kami akan menggunakan port ini semasa kami bekerja dengan aplikasi. Di sini anda boleh melihatnya dalam Dockerfile untuk permohonan SA-Frontend tiada perintah sedemikian. Ini adalah untuk tujuan dokumentasi sahaja, dengan kata lain, konstruk ini adalah untuk pembaca Dockerfile.

Membina imej dan menolaknya ke repositori kelihatan sama seperti contoh sebelumnya. Jika anda belum begitu yakin dengan kebolehan anda, arahan yang sepadan boleh didapati dalam fail README.md dalam folder sa-webapp.

▍Membina imej bekas untuk aplikasi Python

Jika anda melihat pada kandungan fail Dockerfile dalam folder sa-logicanda tidak akan menemui sesuatu yang baru di sana. Arahan untuk membina imej dan menolaknya ke repositori juga sepatutnya biasa kepada anda, tetapi, seperti yang berlaku dengan aplikasi kami yang lain, ia boleh didapati dalam fail README.md dalam folder sa-logic.

▍Menguji aplikasi kontena

Bolehkah anda mempercayai sesuatu yang belum anda uji? saya pun tak boleh. Mari uji bekas kami.

Mari mulakan bekas aplikasi sa-logic dan konfigurasikannya untuk mendengar pada port 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Mari mulakan bekas aplikasi sa-webapp dan konfigurasikannya untuk mendengar pada port 8080. Di samping itu, kita perlu menetapkan port di mana aplikasi Python akan mendengar permintaan daripada aplikasi Java dengan menetapkan semula pembolehubah persekitaran 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
```

Untuk mengetahui cara mengetahui alamat IP bekas atau Docker VM, rujuk fail README.

Mari mulakan bekas aplikasi sa-frontend:

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

Kini segala-galanya sedia untuk menavigasi dalam penyemak imbas ke alamat localhost:80 dan uji apl.

Sila ambil perhatian bahawa jika anda menukar port untuk sa-webapp, atau jika anda menjalankan VM Docker, anda perlu mengedit fail App.js daripada folder sa-frontenddengan menukar alamat IP atau nombor port dalam kaedah analyzeSentence()dengan menggantikan maklumat semasa dan bukannya data usang. Selepas itu, anda perlu memasang semula imej dan menggunakannya.

Inilah rupa rajah aplikasi kami sekarang.

Perkhidmatan mikro dijalankan dalam bekas

Ringkasan: mengapa kita memerlukan kluster Kubernetes?

Kami hanya menyemak fail Dockerfile, bercakap tentang cara membina imej dan menolaknya ke repositori Docker. Di samping itu, kami belajar cara mempercepatkan pemasangan imej menggunakan fail .dockerignore. Akibatnya, perkhidmatan mikro kami kini berjalan dalam bekas Docker. Di sini anda mungkin mempunyai soalan yang berasas sepenuhnya tentang mengapa kami memerlukan Kubernetes. Jawapan kepada soalan ini akan ditumpukan kepada bahagian kedua bahan ini. Sementara itu, pertimbangkan soalan berikut:
Mari kita anggap bahawa aplikasi web analisis teks kami telah menjadi popular di seluruh dunia. Berjuta-juta permintaan datang kepadanya setiap minit. Ini bermakna perkhidmatan mikro sa-webapp и sa-logic akan mengalami tekanan yang sangat besar. Bagaimana untuk menskalakan bekas yang menjalankan perkhidmatan mikro?

Sumber: www.habr.com

Tutorial Kubernetes Bahagian 1: Aplikasi, Perkhidmatan Mikro dan Bekas