Geekly articles weekly

Panduan Kubernetes, Bagian 1: Aplikasi, Layanan Mikro, dan Wadah

Atas permintaan kami, Habr menciptakan hub Kubernetes dan kami senang memposting publikasi pertama di dalamnya. Berlangganan!

Kubernet mudah. Mengapa bank membayar saya banyak uang untuk bekerja di bidang ini, sementara ada yang bisa menguasai teknologi ini hanya dalam beberapa jam?



Jika Anda ragu bahwa Kubernet dapat dipelajari dengan cepat, saya sarankan Anda mencoba melakukannya sendiri. Yaitu, setelah menguasai materi ini, Anda akan dapat menjalankan aplikasi berdasarkan pada microservices di kluster Kubernetes. Saya bisa menjamin ini, karena justru dengan metodologi yang digunakan di sini saya melatih Kubernetes untuk bekerja dengan klien kami. Apa yang membedakan manual ini dari yang lain? Bahkan - banyak hal. Jadi, sebagian besar materi ini dimulai dengan penjelasan tentang hal-hal sederhana - konsep Kubernetes dan fitur-fitur dari tim kubectl. Para penulis materi ini percaya bahwa pembaca mereka akrab dengan pengembangan aplikasi, layanan microser, dan wadah Docker. Kami akan pergi ke arah lain. Pertama, mari kita bicara tentang cara menjalankan aplikasi berbasis pada layanan microser di komputer. Kemudian pertimbangkan perakitan gambar wadah untuk setiap layanan mikro. Setelah itu, kita akan mengenal Kubernetes dan menganalisis penyebaran aplikasi berbasis microservice dalam sebuah cluster yang dikelola oleh Kubernetes.

Pendekatan semacam itu, dengan pendekatan bertahap ke Kubernetes, akan memberikan kedalaman pemahaman yang terjadi pada orang biasa untuk memahami bagaimana sederhananya semuanya diatur dalam Kubernetes. Kubernetes, tentu saja, teknologi sederhana, asalkan siapa pun yang ingin mempelajarinya tahu di mana dan bagaimana ia digunakan.

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

Aplikasi eksperimental


Aplikasi kita hanya akan melakukan satu fungsi. Ia menerima, sebagai input, satu kalimat, dan kemudian, menggunakan sarana analisis teks, melakukan analisis sentimen kalimat ini, menerima perkiraan sikap emosional penulis kalimat terhadap objek tertentu.

Seperti inilah tampilan jendela utama aplikasi ini.


Aplikasi web untuk analisis sentimen teks

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

  • SA-Frontend adalah server web Nginx yang menyajikan Bereaksi file statis.
  • SA-WebApp adalah aplikasi web berbasis Java yang memproses permintaan dari front-end.
  • SA-Logic adalah aplikasi Python yang melakukan analisis sentimen teks.

Penting untuk dicatat bahwa layanan microser tidak ada dalam isolasi. Mereka menerapkan gagasan "pemisahan tugas", tetapi mereka, bagaimanapun, perlu berinteraksi satu sama lain.


Aliran Data Aplikasi

Dalam diagram di atas, Anda dapat melihat tahapan bernomor sistem, menggambarkan aliran data dalam aplikasi. Mari kita analisa mereka:

  1. Browser meminta file index.html dari server (yang, pada gilirannya, mengunduh paket aplikasi Bereaksi).
  2. Pengguna berinteraksi dengan aplikasi, ini menyebabkan panggilan ke aplikasi web berbasis pada Spring.
  3. Aplikasi web mengalihkan permintaan untuk analisis teks ke aplikasi Python.
  4. Aplikasi Python menganalisis nada suara teks dan mengembalikan hasilnya sebagai respons terhadap permintaan.
  5. Aplikasi Spring mengirim respons ke aplikasi Bereaksi (dan itu, pada gilirannya, menunjukkan hasil analisis teks kepada pengguna).

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

Memulai aplikasi berbasis microservice di komputer lokal


Agar aplikasi berfungsi, kita perlu menjalankan ketiga layanan microser. Mari kita mulai dengan yang paling lucu dari mereka - dengan aplikasi front-end.

â–Ť Mengkonfigurasi Bereaksi untuk pengembangan lokal


Untuk menjalankan aplikasi Bereaksi, Anda harus menginstal platform Node.js dan NPM di komputer Anda. Setelah Anda menginstal semua ini, buka terminal ke folder proyek sa-frontend dan jalankan perintah berikut:

 npm install

Berkat pelaksanaan perintah ini, dependensi aplikasi Bereaksi, entri tentang yang ada di file package.json , akan dimuat ke folder node_modules . Setelah dependensi diunduh di folder yang sama, jalankan perintah berikut:

 npm start

Itu saja. Sekarang aplikasi Bereaksi berjalan, akses ke sana dapat diperoleh dengan pergi ke alamat localhost:3000 di browser. Anda dapat mengubah sesuatu dalam kodenya. Anda akan segera melihat efek dari perubahan ini di browser. Ini dimungkinkan berkat penggantian modul yang disebut "hot". Berkat ini, pengembangan front-end berubah menjadi tugas yang sederhana dan menyenangkan.

â–ŤPersiapan aplikasi Bereaksi untuk output ke produksi


Untuk penggunaan sebenarnya dari aplikasi Bereaksi, kita perlu mengubahnya menjadi satu set file statis dan memberikannya kepada klien menggunakan server web.

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

 npm run build

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

ErvMelayani file statis menggunakan alat Nginx


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

Dengan pendekatan ini, file index.html dihasilkan selama pembuatan aplikasi Bereaksi akan tersedia di [your_nginx_installation_dir]/html/index.html . Ini adalah file yang, secara default, masalah server Nginx ketika mengaksesnya. Server dikonfigurasikan untuk mendengarkan pada port 80 , tetapi Anda dapat mengkonfigurasinya seperti yang Anda perlukan dengan mengedit file [your_nginx_installation_dir]/conf/nginx.conf .

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


Bereaksi Aplikasi Dilayani oleh Nginx Server

Jika Anda mengetik sesuatu di bidang Type your sentence sekarang dan klik tombol Send , tidak ada yang terjadi. Tetapi, jika Anda melihat konsol, Anda dapat melihat pesan kesalahan di sana. Untuk memahami dengan tepat di mana kesalahan ini terjadi, mari kita menganalisis kode aplikasi.

â–Ť Analisis kode aplikasi front-end


App.js melihat kode file App.js , kita dapat melihat bahwa mengklik tombol Send memanggil metode analyzeSentence() . Kode untuk metode ini diberikan di bawah ini. Pada saat yang sama, perhatikan fakta bahwa untuk setiap baris yang ada komentar dari bentuk # , ada penjelasan yang diberikan di bawah kode. Dengan cara yang sama, kita akan mem-parsing potongan 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 dijalankan. Dapat dipahami bahwa alamat ini berisi aplikasi yang menunggu permintaan tersebut.

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

 {   sentence: "I like yogobella!" }

3. Setelah menerima tanggapan atas permintaan, status komponen diperbarui. 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 Polarity , karena kondisi yang sesuai akan dipenuhi. Ini adalah bagaimana kami menggambarkan komponen:

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

Kode ini tampaknya berfungsi dengan baik. Apa yang salah di sini? Jika Anda berasumsi bahwa di alamat tempat aplikasi mencoba mengirim permintaan POST, sejauh ini tidak ada yang dapat menerima dan memproses permintaan ini, maka Anda akan benar. Yaitu, untuk memproses permintaan yang tiba di alamat http://localhost:8080/sentiment , kita perlu menjalankan aplikasi web berdasarkan Spring.


Kami membutuhkan aplikasi Spring yang dapat menerima permintaan POST.

â–ŤMengatur aplikasi web berbasis pegas


Untuk menyebarkan aplikasi Spring, Anda perlu JDK8 dan Maven dan variabel lingkungan yang dikonfigurasi dengan benar. Setelah Anda menginstal semua ini, Anda dapat terus mengerjakan proyek kami.

â–ŤPaket aplikasi dalam file jar


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

 mvn install

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

â–ŤMulai aplikasi Java


Buka folder target dan luncurkan aplikasi dengan perintah berikut:

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

Kesalahan akan terjadi selama pelaksanaan perintah ini. Untuk mulai memperbaikinya, kami dapat menganalisis informasi pengecualian di data jejak 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 untuk memastikan makna dari sa.logic.api.url . Mari kita menganalisis kode di mana kesalahan terjadi.

â–Ť Analisis kode aplikasi Java


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

  1. S entimentController memiliki bidang saLogicApiUrl . Nilainya ditentukan oleh properti sa.logic.api.url .
  2. String saLogicApiUrl digabungkan dengan nilai /analyse/sentiment . Bersama-sama mereka membentuk alamat untuk mengakses layanan mikro yang melakukan analisis teks.

â–ŤMengatur nilai properti


Di Spring, sumber standar nilai properti adalah file application.properties , yang dapat ditemukan di sa-webapp/src/main/resources . Tetapi penggunaannya bukan satu-satunya cara untuk menetapkan nilai properti. Anda dapat melakukan ini dengan perintah seperti 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 kami.

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

Agar tidak menyulitkan hidup kita, kami memutuskan bahwa aplikasi Python akan tersedia di localhost:5000 dan mencoba untuk tidak melupakannya. Akibatnya, perintah untuk meluncurkan 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 hanya perlu menjalankan aplikasi Python dan sistem akan berfungsi seperti yang diharapkan.

â–Ť Mengkonfigurasi aplikasi Python


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

â–ŤPenginstalan dependensi


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

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

â–ŤMulai aplikasi


Setelah menginstal dependensi, kami siap meluncurkan aplikasi:

 python sentiment_analysis.py

Setelah menjalankan perintah ini, kami akan diberitahu hal berikut:

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

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

â–Ť Penelitian Kode


Pertimbangkan 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

  1. Inisialisasi Objek Flask .
  2. Mengatur alamat untuk mengeksekusi permintaan POST untuk itu.
  3. Mengambil properti sentence dari badan permintaan.
  4. Menginisialisasi objek TextBlob anonim dan mendapatkan nilai polarity untuk kalimat pertama di badan permintaan (dalam kasus kami, ini adalah satu-satunya kalimat yang dilewati untuk analisis).
  5. Kembalinya respons, yang berisi teks proposal dan indeks polarity dihitung untuknya.
  6. Meluncurkan aplikasi Flask, yang akan tersedia di alamat 0.0.0.0:5000 (Anda juga dapat mengaksesnya menggunakan desain formulir localhost:5000 ).

Sekarang layanan microser yang membentuk aplikasi sedang berjalan. Mereka dikonfigurasikan untuk saling berinteraksi. Beginilah tampilan diagram aplikasi pada tahap kerja ini.


Semua layanan microser yang membentuk aplikasi dibawa ke keadaan sehat.

Sekarang, sebelum melanjutkan, buka aplikasi Bereaksi di browser dan cobalah untuk menganalisis beberapa saran menggunakannya. Jika semuanya dilakukan dengan benar, setelah mengklik tombol Send , Anda akan melihat hasil analisis di bawah kotak teks.

Di bagian berikutnya, kita akan berbicara tentang cara menjalankan layanan microser kami dalam wadah Docker. Ini diperlukan untuk menyiapkan aplikasi untuk diluncurkan di kluster Kubernetes.

Wadah Docker


Kubernetes adalah sistem untuk mengotomatiskan penyebaran, penskalaan, dan pengelolaan aplikasi kemas. Itu juga disebut "wadah orkestra". Jika Kubernet bekerja dengan kontainer, pertama-tama kita harus memperoleh kontainer ini sebelum menggunakan sistem ini. Tapi pertama-tama, mari kita bicara tentang wadah apa. Mungkin jawaban terbaik untuk pertanyaan tentang apa itu dapat ditemukan di dokumentasi untuk Docker:

Gambar kontainer adalah paket yang ringan, berdiri sendiri, dan dapat dijalankan yang berisi aplikasi yang mencakup semua yang Anda perlukan untuk menjalankannya: kode aplikasi, runtime, alat sistem dan pustaka, dan pengaturan. Program kemas dapat digunakan di lingkungan Linux dan Windows, dan mereka akan selalu bekerja sama terlepas dari infrastruktur.

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

Untuk menjelajahi fitur wadah dan membandingkannya dengan cara lain untuk meluncurkan aplikasi, pertimbangkan contoh melayani aplikasi Bereaksi menggunakan mesin virtual dan wadah.

ErvMelayani React file aplikasi statis menggunakan mesin virtual


Mencoba mengatur pemeliharaan file statis dengan menggunakan mesin virtual, kita akan menghadapi kekurangan berikut:

  1. Penggunaan sumber daya yang tidak efisien, karena setiap mesin virtual adalah sistem operasi yang lengkap.
  2. Ketergantungan platform. Apa yang berfungsi pada komputer lokal tertentu mungkin tidak berfungsi pada server produksi.
  3. Penskalaan lambat dan sumber daya intensif dari solusi berbasis mesin virtual.


Server web server statis Nginx berjalan pada mesin virtual

Jika kontainer digunakan untuk memecahkan masalah yang sama, maka, dibandingkan dengan mesin virtual, kekuatan berikut dapat dicatat:

  1. Penggunaan sumber daya yang efisien: bekerja dengan sistem operasi menggunakan Docker.
  2. Kemandirian platform. Wadah yang dapat dijalankan oleh pengembang di komputernya akan berfungsi di mana saja.
  3. Penerapan ringan melalui penggunaan lapisan gambar.


Nginx server statis server web berjalan dalam wadah

Kami membandingkan mesin dan wadah virtual hanya pada beberapa titik, tetapi bahkan ini sudah cukup untuk merasakan kekuatan dari wadah tersebut. Cari tahu lebih lanjut tentang wadah Docker di sini.

â–Ť Merakit gambar kontainer untuk aplikasi Bereaksi


Blok bangunan utama wadah Docker adalah Dockerfile . Pada awal file ini, buatlah rekaman gambar dasar wadah, kemudian mereka memasukkan urutan instruksi yang menunjukkan urutan pembuatan wadah yang akan memenuhi kebutuhan aplikasi tertentu.

Sebelum kita mulai bekerja dengan Dockerfile , mari kita mengingat kembali apa yang telah kita lakukan untuk mempersiapkan file aplikasi Bereaksi untuk diunggah ke server Nginx:

  1. Bangun paket aplikasi Bereaksi ( npm run build ).
  2. Mulai server Nginx.
  3. Salin isi direktori build dari folder sa-frontend project ke folder server nginx/html .

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

â–ŤMenyiapkan Dockerfile untuk SA-Frontend


Instruksi yang akan dimuat dalam Dockerfile untuk aplikasi SA-Frontend hanya terdiri dari dua perintah. Faktanya adalah bahwa tim pengembangan Nginx menyiapkan gambar dasar untuk Nginx, yang akan kita gunakan untuk membuat gambar kita. Berikut adalah dua langkah yang perlu kami jelaskan:

  1. Dasar dari gambar yang Anda butuhkan untuk membuat gambar Nginx.
  2. Isi folder sa-frontend/build harus disalin ke folder gambar nginx/html .

Jika kita berpindah dari deskripsi ini ke Dockerfile , maka akan terlihat seperti ini:

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

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

Di sini Anda mungkin memiliki pertanyaan tentang di mana saya tahu tentang di mana tepatnya menyalin file dari folder build , yaitu dari mana path /usr/share/nginx/html berasal. Bahkan, dan tidak ada yang rumit. Faktanya adalah bahwa informasi yang relevan dapat ditemukan dalam deskripsi gambar.

â–ŤMembangun gambar dan mengunggahnya ke repositori


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

  1. Instal Docker .
  2. Daftar di situs Docker Hub.
  3. Masuk ke akun 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 menjalankan perintah berikut di sana:

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

Selanjutnya dalam perintah serupa, $DOCKER_USER_ID perlu diganti dengan nama pengguna Anda di Docker Hub. Sebagai contoh, bagian dari perintah ini mungkin terlihat seperti ini: rinormaloku/sentiment-analysis-frontend .

Pada saat yang sama, perintah ini dapat dipersingkat dengan menghapus -f Dockerfile darinya, karena file ini sudah ada di folder tempat kami menjalankan perintah ini.

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

 docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Setelah eksekusi, periksa daftar repositori Anda di Docker Hub untuk memahami apakah gambar berhasil dikirim ke cloud.

â–Ť Mulai wadah


Sekarang siapa pun dapat mengunduh dan menjalankan gambar yang dikenal sebagai $DOCKER_USER_ID/sentiment-analysis-frontend . Untuk melakukan ini, Anda harus 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 wadah diluncurkan, dan kami dapat terus bekerja, menciptakan gambar lain yang kami butuhkan. Tapi, sebelum melanjutkan, mari kita 80:80 konstruksi 80:80 , yang ditemukan dalam perintah peluncuran gambar dan mungkin tampak tidak bisa dipahami.

  • Angka pertama 80 adalah nomor port host (yaitu, komputer lokal).
  • Angka kedua 80 adalah pelabuhan wadah yang permintaannya harus dialihkan.

Perhatikan ilustrasi berikut.


Penerusan port

Sistem mengalihkan permintaan dari port <hostPort> ke port <containerPort> . Artinya, akses ke port 80 komputer dialihkan ke port 80 wadah.

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

Pada tahap ini, setelah berhasil meluncurkan wadah aplikasi frontend, Anda harus dapat membuka halamannya di browser.

â–Ť .dockerignore file


Mengumpulkan gambar aplikasi SA-Frontend , kita dapat melihat bahwa proses ini sangat lambat. Ini terjadi karena fakta bahwa konteks build dari gambar harus dikirim ke daemon Docker. Direktori yang mewakili konteks build ditentukan oleh argumen terakhir ke docker build . Dalam kasus kami, pada akhir perintah ini adalah titik. Ini menghasilkan struktur berikut yang termasuk dalam konteks perakitan:

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

Tapi dari semua folder yang ada di sini, kita hanya perlu folder build . Mengunduh hal lain adalah buang-buang waktu. Build dapat dipercepat dengan memberi tahu Docker direktori mana yang harus diabaikan. Untuk melakukan ini kita perlu file .dockerignore . Jika Anda terbiasa dengan file .gitignore , struktur file ini pasti tampak akrab. Ini daftar direktori yang mungkin diabaikan sistem perakitan gambar. Dalam kasus kami, isi file ini terlihat seperti ini:

 node_modules src public

File .dockerignore harus berada di folder yang sama dengan Dockerfile . Sekarang merakit gambar akan membutuhkan waktu beberapa detik.

Sekarang mari kita lihat aplikasi 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 .

â–Ť


- , ? . .

  1. sa-logic 5050 :

     docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
  2. 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 — README .

sa-frontend :

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

, localhost:80 .

, sa-webapp , Docker, App.js sa-frontend , IP- analyzeSentence() , . .

.




: Kubernetes?


Dockerfile , , Docker. , , .dockerignore . Docker. , Kubernetes. . :
, - . . , sa-webapp sa-logic . , ?

Source: https://habr.com/ru/post/id438982/

More articles:


All Articles