🥇Tutorial Kubernetes Bagian 1: Aplikasi, Layanan Mikro, dan Kontainer

Atas permintaan kami, Habr membuat hub Kubernetes dan kami dengan senang hati menempatkan publikasi pertama di dalamnya. Langganan!

Kubernet mudah. Mengapa bank membayar saya banyak uang untuk bekerja di bidang ini, sementara siapa pun dapat menguasai teknologi ini hanya dalam beberapa jam?

Jika Anda ragu Kubernet dapat dipelajari dengan begitu cepat, saya sarankan Anda mencoba melakukannya sendiri. Yaitu, setelah menguasai materi ini, Anda akan dapat menjalankan aplikasi berbasis layanan mikro di cluster Kubernetes. Saya dapat menjamin ini, karena dalam metodologi yang sama yang saya gunakan di sini saya mengajari klien kami cara bekerja dengan Kubernetes. Apa yang membuat panduan ini berbeda dari yang lain? Sebenarnya, banyak hal. Jadi, sebagian besar materi ini dimulai dengan penjelasan tentang hal-hal sederhana - konsep Kubernetes dan fitur perintah kubectl. Penulis artikel ini berasumsi bahwa pembacanya sudah familiar dengan pengembangan aplikasi, layanan mikro, dan wadah Docker. Kami akan pergi ke arah lain. Pertama, mari kita bicara tentang cara menjalankan aplikasi berbasis layanan mikro di komputer. Kemudian kita akan melihat gambar wadah bangunan untuk setiap layanan mikro. Dan setelah itu, kita akan berkenalan dengan Kubernetes dan menganalisis penerapan aplikasi berbasis layanan mikro di cluster yang dikelola oleh Kubernetes.

Pendekatan ini, dengan pendekatan bertahap ke Kubernetes, akan memberikan kedalaman pemahaman tentang apa yang terjadi yang dibutuhkan rata-rata orang untuk memahami betapa sederhananya segala sesuatu diatur di Kubernetes. Kubernetes tentu saja merupakan teknologi sederhana, asalkan siapa pun yang ingin menguasainya tahu di mana dan bagaimana penggunaannya.

Sekarang, tanpa basa-basi lagi, mari mulai bekerja dan membicarakan tentang aplikasi yang akan kita kerjakan.

Aplikasi eksperimental

Aplikasi kita hanya akan menjalankan satu fungsi. Dibutuhkan, sebagai masukan, satu kalimat, setelah itu, dengan menggunakan alat analisis teks, ia melakukan analisis sentimen kalimat ini, memperoleh penilaian sikap emosional penulis kalimat terhadap objek tertentu.

Seperti inilah tampilan jendela utama aplikasi ini.

Aplikasi Web Analisis Sentimen

Dari sudut pandang teknis, aplikasi ini terdiri dari tiga layanan mikro, yang masing-masing menyelesaikan serangkaian tugas tertentu:

SA-Frontend adalah server web Nginx yang melayani React file statis.
SA-WebApp adalah aplikasi web yang ditulis dalam Java yang menangani permintaan dari frontend.
SA-Logic adalah aplikasi Python yang melakukan analisis sentimen teks.

Penting untuk dicatat bahwa layanan mikro tidak ada secara terpisah. Mereka menerapkan gagasan "pemisahan tugas", tetapi pada saat yang sama mereka perlu berinteraksi satu sama lain.

Data mengalir dalam aplikasi

Pada diagram di atas, Anda dapat melihat tahapan sistem bernomor yang menggambarkan aliran data dalam aplikasi. Mari kita uraikan:

Browser meminta file dari server index.html (yang pada gilirannya memuat paket aplikasi React).
Pengguna berinteraksi dengan aplikasi, ini menyebabkan panggilan ke aplikasi web berbasis Spring.
Aplikasi web meneruskan permintaan untuk mengurai teks ke aplikasi Python.
Aplikasi Python menganalisis sentimen teks dan mengembalikan hasilnya sebagai respons terhadap permintaan.
Aplikasi Spring mengirimkan respons ke aplikasi React (yang, pada gilirannya, menampilkan hasil teks yang diurai kepada pengguna).

Kode untuk semua aplikasi ini dapat ditemukan di sini. Saya sarankan Anda menyalin repositori ini ke diri Anda sendiri sekarang, karena ada banyak eksperimen menarik di depan kita.

Menjalankan aplikasi berdasarkan layanan mikro di mesin lokal

Agar aplikasi berfungsi, kita perlu memulai ketiga layanan mikro. Mari kita mulai dengan yang tercantik - aplikasi front-end.

▍Menyiapkan React untuk pengembangan lokal

Untuk menjalankan aplikasi React, Anda perlu menginstal framework Node.js dan NPM di komputer Anda. Setelah Anda menginstal semua ini, gunakan terminal ke folder proyek sa-frontend dan jalankan perintah berikut:

npm install

Dengan menjalankan perintah ini di folder node_modules dependensi aplikasi React akan dimuat, yang rekamannya ada di dalam file package.json. Setelah mengunduh dependensi di folder yang sama, jalankan perintah berikut:

npm start

Itu saja. Aplikasi React sekarang berjalan dan dapat diakses dengan menavigasi ke alamat browser localhost:3000. Anda dapat mengubah sesuatu dalam kodenya. Anda akan segera melihat efek dari perubahan ini di browser. Ini dimungkinkan berkat apa yang disebut penggantian modul "panas". Berkat ini, pengembangan front-end berubah menjadi pengalaman yang sederhana dan menyenangkan.

▍Mempersiapkan aplikasi React untuk produksi

Untuk tujuan benar-benar menggunakan aplikasi React, kita perlu mengubahnya menjadi sekumpulan file statis dan menyajikannya ke klien menggunakan server web.

Untuk membangun aplikasi React, sekali lagi menggunakan terminal, arahkan ke folder sa-frontend dan jalankan perintah berikut:

npm run build

Ini akan membuat direktori di folder proyek build. Ini akan berisi semua file statis yang diperlukan agar aplikasi React berfungsi.

▍Menyajikan file statis dengan Nginx

Pertama, Anda perlu menginstal dan menjalankan server web Nginx. Di sini Anda dapat mengunduhnya dan menemukan petunjuk untuk memasang dan menjalankannya. Maka Anda perlu menyalin isi folder sa-frontend/build ke folder [your_nginx_installation_dir]/html.

Dengan pendekatan ini, file dihasilkan selama perakitan aplikasi React index.html akan tersedia di [your_nginx_installation_dir]/html/index.html. Ini adalah file yang, secara default, dikeluarkan oleh server Nginx saat mengaksesnya. Server dikonfigurasi untuk mendengarkan pada port 80, tetapi Anda dapat menyesuaikannya seperti yang Anda inginkan dengan mengedit file [your_nginx_installation_dir]/conf/nginx.conf.

Sekarang buka browser Anda dan pergi ke localhost:80. Anda akan melihat halaman aplikasi Bereaksi.

Bereaksi aplikasi yang dilayani oleh server Nginx

Jika Anda sekarang memasukkan sesuatu di lapangan Type your sentence dan tekan tombol Send - Tidak ada yang akan terjadi. Tapi, jika Anda melihat konsolnya, Anda bisa melihat pesan kesalahan di sana. Untuk memahami dengan tepat di mana kesalahan ini terjadi, mari kita menganalisis kode aplikasinya.

▍Analisis kode aplikasi front-end

Melihat kode file App.js, kita dapat melihat bahwa mengklik tombol Send memanggil sebuah metode analyzeSentence(). Kode untuk metode ini ditunjukkan di bawah ini. Pada saat yang sama, perhatikan fakta bahwa untuk setiap baris yang berisi komentar formulir # Номер, ada penjelasan yang diberikan di bawah kode. Dengan cara yang sama, kami akan mengurai fragmen kode lainnya.

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 tempat permintaan POST dibuat. Alamat ini dianggap sebagai aplikasi yang menunggu permintaan tersebut.

2.Badan permintaan dikirim ke aplikasi. Berikut adalah contoh badan permintaan:

{
    sentence: "I like yogobella!"
}

3.Saat respons terhadap permintaan diterima, status komponen diperbarui. Hal ini menyebabkan komponen merender ulang. Jika kami menerima data (yaitu objek JSON yang berisi data yang dimasukkan dan skor teks yang dihitung), kami akan menampilkan komponen Polarityasalkan syaratnya terpenuhi. Berikut adalah cara kami mendeskripsikan komponen:

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

Kode tampaknya bekerja dengan cukup baik. Apa yang salah di sini? Jika Anda berasumsi bahwa di alamat tujuan aplikasi mencoba mengirim permintaan POST, belum ada yang dapat menerima dan memproses permintaan ini, maka Anda benar sekali. Yaitu, untuk memproses permintaan yang datang ke alamat http://localhost:8080/sentiment, kita perlu menjalankan aplikasi web berbasis Spring.

Kami membutuhkan aplikasi Spring yang dapat menerima permintaan POST

▍Menyiapkan aplikasi web berdasarkan Spring

Untuk menerapkan aplikasi Spring, Anda memerlukan JDK8 dan Maven serta variabel lingkungan yang dikonfigurasi dengan benar. Setelah Anda menginstal semua ini, Anda dapat melanjutkan mengerjakan proyek kami.

▍Kemas aplikasi ke dalam file jar

Arahkan, menggunakan terminal, ke folder sa-webapp dan masukkan perintah berikut:

mvn install

Setelah menjalankan perintah ini di folder sa-webapp direktori akan dibuat target. Di sinilah aplikasi Java akan ditempatkan, dikemas dalam file jar, diwakili oleh file tersebut sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Meluncurkan Aplikasi Java

Masuk ke folder target dan jalankan aplikasi dengan perintah berikut:

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

Kesalahan akan terjadi saat menjalankan perintah ini. Untuk mulai memperbaikinya, kita dapat mengurai detail pengecualian dalam data pelacakan tumpukan:

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, hal terpenting di sini adalah penyebutan ketidakmungkinan memperjelas makna sa.logic.api.url. Mari kita menganalisis kode di mana kesalahan terjadi.

▍Analisis kode aplikasi Java

Berikut cuplikan kode tempat kesalahan terjadi.

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

Di SentimentController ada lapangan saLogicApiUrl. Nilainya ditentukan oleh properti sa.logic.api.url.
Tali saLogicApiUrl menyatu dengan nilai /analyse/sentiment. Bersama-sama mereka membentuk alamat untuk melakukan panggilan ke layanan mikro yang melakukan analisis teks.

▍Menetapkan nilai properti

Di Spring, sumber default nilai properti adalah file application.properties, yang dapat ditemukan di sa-webapp/src/main/resources. Tetapi menggunakannya bukan satu-satunya cara untuk menetapkan nilai properti. Anda juga dapat melakukan ini dengan perintah berikut:

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

Nilai properti ini harus mengarah ke alamat aplikasi Python kita.

Dengan mengonfigurasinya, kami memberi tahu aplikasi web Spring ke mana ia harus pergi untuk mengeksekusi permintaan parsing teks.

Agar tidak mempersulit hidup kita, kita akan memutuskan bahwa aplikasi Python akan tersedia di localhost:5000 dan mencoba untuk tidak melupakannya. Hasilnya, perintah untuk memulai aplikasi Spring akan terlihat seperti ini:

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

Sistem kami tidak memiliki aplikasi Python

Sekarang kita tinggal menjalankan aplikasi Python dan sistem akan bekerja seperti yang diharapkan.

▍Menyiapkan aplikasi Python

Untuk menjalankan aplikasi Python, Anda harus menginstal Python 3 dan Pip, dan Anda harus mengatur variabel lingkungan yang sesuai dengan benar.

▍Instal dependensi

Buka folder proyek sa-logic/sa dan jalankan perintah berikut:

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

▍ Peluncuran aplikasi

Dengan dependensi terpasang, kami siap menjalankan aplikasi:

python sentiment_analysis.py

Setelah menjalankan perintah ini, kita akan diberitahu sebagai berikut:

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

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

▍Penelitian kode

Mari kita lihat kode aplikasi Python untuk memahami bagaimana responsnya terhadap 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 ke sana.
Mengambil properti sentence dari badan permintaan.
Inisialisasi objek anonim TextBlob dan mendapatkan nilainya polarity untuk proposal pertama yang diterima di badan permintaan (dalam kasus kami, ini adalah satu-satunya proposal yang diajukan untuk analisis).
Mengembalikan respons, yang isinya berisi teks penawaran dan indikator yang dihitung untuknya polarity.
Meluncurkan aplikasi Flask, yang akan tersedia di 0.0.0.0:5000 (Anda juga dapat mengaksesnya menggunakan konstruksi formulir localhost:5000).

Sekarang layanan mikro yang membentuk aplikasi sedang berjalan. Mereka diatur untuk berinteraksi satu sama lain. Berikut adalah tampilan diagram aplikasi pada tahap pekerjaan ini.

Semua layanan mikro yang membentuk aplikasi dibawa ke kondisi sehat

Sekarang, sebelum kita melanjutkan, buka aplikasi React di browser dan coba parsing beberapa kalimat dengannya. Jika semuanya dilakukan dengan benar - setelah menekan tombol Send Anda akan melihat hasil analisis di bawah kotak teks.

Di bagian selanjutnya, kita akan berbicara tentang cara menjalankan layanan mikro di wadah Docker. Ini diperlukan untuk menyiapkan aplikasi agar dapat berjalan di cluster Kubernetes.

Kontainer buruh pelabuhan

Kubernetes adalah sistem untuk mengotomatiskan penerapan, penskalaan, dan pengelolaan aplikasi dalam container. Itu juga disebut "orkestra wadah". Jika Kubernetes bekerja dengan container, maka sebelum menggunakan sistem ini, pertama-tama kita harus mendapatkan container ini. Tapi pertama-tama, mari kita bicara tentang apa itu wadah. Mungkin jawaban terbaik untuk pertanyaan tentang apa itu dapat ditemukan dokumentasi ke Docker:

Gambar kontainer adalah paket ringan, mandiri, dan dapat dieksekusi yang berisi aplikasi, yang mencakup semua yang diperlukan untuk menjalankannya: kode aplikasi, lingkungan runtime, alat sistem dan pustaka, pengaturan. Program kemas dapat digunakan di lingkungan Linux dan Windows dan akan selalu bekerja sama terlepas dari infrastrukturnya.

Ini berarti wadah dapat dijalankan di komputer mana pun, termasuk server produksi, dan di lingkungan apa pun, aplikasi yang ada di dalamnya akan bekerja dengan cara yang sama.

Untuk mengeksplorasi fitur kontainer dan membandingkannya dengan cara lain untuk menjalankan aplikasi, mari kita lihat contoh melayani aplikasi React menggunakan mesin virtual dan kontainer.

▍Menyajikan file statis dari aplikasi React menggunakan mesin virtual

Mencoba mengatur pemeliharaan file statis menggunakan mesin virtual, kami akan menemui kerugian berikut:

Penggunaan sumber daya yang tidak efisien, karena setiap mesin virtual adalah sistem operasi yang lengkap.
Ketergantungan platform. Apa yang berfungsi di beberapa komputer lokal mungkin tidak berfungsi di server produksi.
Penskalaan lambat dan intensif sumber daya dari solusi mesin virtual.

Server web Nginx melayani file statis yang berjalan di mesin virtual

Jika wadah digunakan untuk memecahkan masalah serupa, maka dibandingkan dengan mesin virtual, kekuatan berikut dapat dicatat:

Penggunaan sumber daya yang efisien: bekerja dengan sistem operasi menggunakan Docker.
Kemandirian platform. Wadah yang dapat dijalankan pengembang di komputernya sendiri akan berjalan di mana saja.
Penyebaran ringan melalui penggunaan lapisan gambar.

Server web Nginx menyajikan file statis yang berjalan dalam wadah

Kami hanya membandingkan mesin virtual dan wadah pada beberapa poin, tetapi itu pun sudah cukup untuk merasakan kekuatan wadah. Di sini Anda dapat menemukan detail tentang kontainer Docker.

▍Membangun gambar kontainer untuk aplikasi React

Blok penyusun dasar wadah Docker adalah file Dockerfile. Di awal file ini, gambar dasar wadah direkam, kemudian disertakan urutan instruksi yang menunjukkan cara membuat wadah yang akan memenuhi kebutuhan aplikasi.

Sebelum kita mulai bekerja dengan file Dockerfile, ingat apa yang kami lakukan untuk menyiapkan file aplikasi React untuk diunggah ke server Nginx:

Membangun paket aplikasi React (npm run build).
Memulai server Nginx.
Menyalin isi direktori build dari folder proyek sa-frontend ke folder server nginx/html.

Di bawah ini Anda dapat melihat kesejajaran antara membuat wadah dan tindakan di atas yang dilakukan di komputer lokal.

▍Mempersiapkan Dockerfile untuk Aplikasi SA-Frontend

Instruksi yang harus disertakan Dockerfile untuk aplikasi SA-Frontend, hanya terdiri dari dua tim. Faktanya, tim pengembangan Nginx telah menyiapkan basis sebuah gambar untuk Nginx, yang akan kita gunakan untuk membangun citra kita. Berikut adalah dua langkah yang perlu kami uraikan:

Anda perlu menjadikan gambar Nginx sebagai dasar gambar.
Konten folder sa-frontend/build perlu menyalin ke folder gambar nginx/html.

Jika kita beralih dari deskripsi ini ke file Dockerfile, maka tampilannya akan seperti ini:

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

Seperti yang Anda lihat, semuanya di sini sangat sederhana, sementara konten file ternyata cukup mudah dibaca dan dimengerti. File ini memberi tahu sistem untuk mengambil gambar nginx dengan semua yang sudah dimilikinya, dan salin isi direktori build ke direktori nginx/html.

Di sini Anda mungkin memiliki pertanyaan tentang bagaimana saya tahu di mana tepatnya menyalin file dari folder build, yaitu dari mana jalan itu berasal /usr/share/nginx/html. Nyatanya, tidak ada yang rumit di sini juga. Faktanya adalah bahwa informasi yang relevan dapat ditemukan di keterangan gambar.

▍ Merakit gambar dan mengunggahnya ke repositori

Sebelum kita dapat bekerja dengan gambar yang sudah selesai, kita perlu mengirimkannya ke repositori gambar. Untuk melakukan ini, kami akan menggunakan platform hosting gambar gratis berbasis cloud, Docker Hub. Pada tahap pekerjaan ini, Anda perlu melakukan hal berikut:

Untuk menginstal Buruh pelabuhan.
Daftar di situs Docker Hub.
Masuk ke akun Anda dengan menjalankan perintah berikut di terminal:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Sekarang Anda perlu menggunakan terminal untuk pergi ke direktori sa-frontend dan jalankan perintah berikut di sana:

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

Di sini dan di bawah dalam perintah serupa $DOCKER_USER_ID harus diganti dengan nama pengguna Anda di Docker Hub. Misalnya, bagian dari perintah ini mungkin terlihat seperti ini: rinormaloku/sentiment-analysis-frontend.

Dalam hal ini, perintah ini dapat dipersingkat dengan menghapusnya -f Dockerfile, karena folder tempat kami menjalankan perintah ini sudah memiliki file ini.

Untuk mengirim gambar yang sudah jadi ke repositori, kita memerlukan perintah berikut:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Setelah menyelesaikannya, periksa daftar repositori Anda di Docker Hub untuk melihat apakah image berhasil didorong ke penyimpanan cloud.

▍Memulai wadah

Sekarang siapa pun dapat mengunduh dan menjalankan gambar yang dikenal sebagai $DOCKER_USER_ID/sentiment-analysis-frontend. Untuk melakukan ini, Anda perlu menjalankan urutan perintah berikut:

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

Sekarang penampung sedang berjalan, dan kita dapat terus bekerja dengan membuat gambar lain yang kita perlukan. Namun sebelum kita melanjutkan, mari kita pahami desainnya 80:80, yang ditemukan di perintah untuk menjalankan gambar dan mungkin tampak membingungkan.

nomor pertama 80 adalah nomor port dari host (yaitu, komputer lokal).
Nomor kedua 80 adalah port wadah tempat permintaan harus dialihkan.

Perhatikan ilustrasi berikut.

Penerusan Pelabuhan

Sistem meneruskan permintaan dari port <hostPort> ke pelabuhan <containerPort>. Yaitu, mengakses port 80 komputer dialihkan ke port 80 wadah.

Sejak pelabuhan 80 dibuka di komputer lokal, Anda dapat mengakses aplikasi dari komputer ini di localhost:80. Jika sistem Anda tidak mendukung Docker, Anda dapat menjalankan aplikasi di mesin virtual Docker, yang alamatnya akan terlihat seperti <docker-machine ip>:80. Untuk mengetahui alamat IP mesin virtual Docker, Anda dapat menggunakan perintah docker-machine ip.

Pada titik ini, setelah penampung aplikasi front-end berhasil diluncurkan, Anda seharusnya dapat membuka halamannya di browser.

▍.dockerignore file

Membangun gambar aplikasi SA-Frontend, kami dapat melihat bahwa proses ini sangat lambat. Ini karena konteks pembuatan gambar harus dikirim ke daemon Docker. Direktori yang merepresentasikan konteks build diberikan sebagai argumen terakhir pada perintah docker build. Dalam kasus kami, ada titik di akhir perintah ini. Ini menghasilkan struktur berikut yang disertakan dalam konteks perakitan:

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

Namun dari semua folder yang ada disini, kita hanya membutuhkan sebuah folder build. Mengunduh yang lain hanya membuang-buang waktu. Anda dapat mempercepat pembangunan dengan memberi tahu Docker direktori mana yang harus diabaikan. Untuk melakukan ini, kita membutuhkan file .dockerignore. Anda, jika Anda sudah familiar dengan file tersebut .gitignore, struktur file ini mungkin terlihat familier. Ini mencantumkan direktori yang dapat diabaikan oleh sistem image build. Dalam kasus kami, isi file ini terlihat seperti ini:

node_modules
src
public

berkas .dockerignore harus berada di folder yang sama dengan file Dockerfile. Sekarang perakitan gambar akan memakan waktu beberapa detik.

Sekarang mari kita berurusan dengan image untuk aplikasi Java.

▍Membangun citra wadah untuk aplikasi Java

Anda tahu, dan Anda telah mempelajari semua yang Anda butuhkan untuk membuat gambar kontainer. Itu sebabnya bagian ini akan sangat singkat.

Buka filenya Dockerfile, yang terletak di folder proyek sa-webapp. Jika Anda membaca teks file ini, maka di dalamnya Anda hanya akan menemukan dua konstruksi baru yang dimulai dengan kata kunci ENV и EXPOSE:

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

Kata kunci ENV memungkinkan Anda untuk mendeklarasikan variabel lingkungan di dalam wadah Docker. Secara khusus, dalam kasus kami, ini memungkinkan Anda menyetel URL untuk mengakses API aplikasi yang melakukan analisis teks.

Kata kunci EXPOSE memungkinkan Anda memberi tahu Docker untuk membuka port. Kami akan menggunakan port ini saat kami bekerja dengan aplikasi. Di sini Anda dapat melihatnya di Dockerfile untuk aplikasi SA-Frontend tidak ada perintah seperti itu. Ini hanya untuk keperluan dokumentasi, dengan kata lain konstruk ini untuk pembaca Dockerfile.

Membuat gambar dan mendorongnya ke repositori terlihat persis seperti contoh sebelumnya. Jika Anda belum terlalu yakin dengan kemampuan Anda, perintah yang sesuai dapat ditemukan di file README.md dalam folder sa-webapp.

▍Membangun citra wadah untuk aplikasi Python

Jika Anda melihat isi file tersebut Dockerfile dalam folder sa-logicAnda tidak akan menemukan sesuatu yang baru di sana. Perintah untuk membuat gambar dan mendorongnya ke repositori juga harus Anda ketahui, tetapi, seperti halnya dengan aplikasi kami yang lain, perintah tersebut dapat ditemukan di file README.md dalam folder sa-logic.

▍Menguji aplikasi dalam container

Bisakah Anda mempercayai sesuatu yang belum Anda uji? Saya juga tidak bisa. Mari kita uji wadah kita.

Mari mulai wadah aplikasi sa-logic dan konfigurasikan untuk mendengarkan di port 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Mari mulai wadah aplikasi sa-webapp dan konfigurasikan untuk mendengarkan di port 8080. Selain itu, kita perlu menyetel port tempat aplikasi Python akan mendengarkan permintaan dari aplikasi Java dengan menugaskan ulang variabel lingkungan 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 mempelajari cara mengetahui alamat IP wadah atau VM Docker, lihat file README.

Mari mulai wadah aplikasi sa-frontend:

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

Sekarang semuanya siap untuk dinavigasi di browser ke alamat localhost:80 dan menguji aplikasi.

Harap dicatat bahwa jika Anda mengubah port untuk sa-webapp, atau jika Anda menjalankan Docker VM, Anda harus mengedit file tersebut App.js dari folder sa-frontenddengan mengubah alamat IP atau nomor port dalam metode analyzeSentence()dengan mengganti informasi saat ini bukan data usang. Setelah itu, Anda perlu memasang kembali gambar dan menggunakannya.

Seperti inilah tampilan diagram aplikasi kita sekarang.

Layanan mikro berjalan dalam wadah

Rangkuman: mengapa kita membutuhkan kluster Kubernetes?

Kami baru saja meninjau file Dockerfile, berbicara tentang cara membuat image dan mendorongnya ke repositori Docker. Selain itu, kami mempelajari cara mempercepat perakitan gambar menggunakan file .dockerignore. Akibatnya, layanan mikro kami sekarang berjalan di wadah Docker. Di sini Anda mungkin memiliki pertanyaan yang sepenuhnya masuk akal tentang mengapa kami membutuhkan Kubernetes. Jawaban atas pertanyaan ini akan dikhususkan untuk bagian kedua dari materi ini. Sementara itu, pertimbangkan pertanyaan berikut:
Mari kita asumsikan bahwa aplikasi web analisis teks kita telah menjadi populer di seluruh dunia. Jutaan permintaan datang kepadanya setiap menit. Ini berarti bahwa layanan mikro sa-webapp и sa-logic akan mengalami tekanan yang sangat besar. Bagaimana cara menskalakan wadah yang menjalankan layanan mikro?

Sumber: www.habr.com

Tutorial Kubernetes Bagian 1: Aplikasi, Layanan Mikro, dan Kontainer