🥇Kubernetes Eğitimi 1. Bölüm: Uygulamalar, Mikro Hizmetler ve Konteynerler

İsteğimiz üzerine Habr bir merkez oluşturdu Kubernetes ve ilk yayını içine yerleştirmekten mutluluk duyuyoruz. Abone!

Kubernet'ler kolaydır. Herkes birkaç saat içinde bu teknolojide ustalaşabilecekken, neden bankalar bu alanda çalışmam için bana çok para ödüyor?

Kubernetes'in bu kadar hızlı öğrenilebileceğinden şüpheniz varsa, bunu kendiniz yapmayı denemenizi öneririm. Yani, bu malzemeye hakim olduktan sonra, bir Kubernetes kümesinde mikro hizmetlere dayalı bir uygulama çalıştırabileceksiniz. Bunu garanti edebilirim çünkü burada kullandığım metodolojiyle müşterilerimize Kubernetes ile nasıl çalışacaklarını öğretiyorum. Bu kılavuzu diğerlerinden farklı kılan nedir? Aslında pek çok şey. Dolayısıyla, bu materyallerin çoğu basit şeylerin - Kubernet kavramları ve kubectl komutunun özellikleri - açıklanmasıyla başlar. Bu makalelerin yazarları, okuyucularının uygulama geliştirme, mikro hizmetler ve Docker kapsayıcılarına aşina olduğunu varsayar. Diğer yoldan gideceğiz. İlk olarak, bir bilgisayarda mikro hizmetlere dayalı bir uygulamanın nasıl çalıştırılacağından bahsedelim. Ardından, her bir mikro hizmet için kapsayıcı görüntüleri oluşturmaya bakacağız. Ardından Kubernetes ile tanışacağız ve Kubernetes tarafından yönetilen bir kümede mikro hizmetlere dayalı bir uygulamanın dağıtımını analiz edeceğiz.

Kubernetes'e kademeli bir yaklaşımla bu yaklaşım, Kubernetes'te her şeyin ne kadar basit düzenlendiğini anlamak için ortalama bir kişinin ihtiyaç duyduğu, neler olup bittiğine dair derinlemesine bir anlayış sağlayacaktır. Kubernetes, ustalaşmak isteyenlerin nerede ve nasıl kullanıldığını bilmesi koşuluyla kesinlikle basit bir teknolojidir.

Şimdi lafı daha fazla uzatmadan işe koyulalım ve üzerinde çalışacağımız uygulamadan bahsedelim.

deneysel uygulama

Uygulamamız sadece bir işlevi yerine getirecektir. Girdi olarak bir cümle alır, ardından metin analiz araçlarını kullanarak bu cümlenin duygu analizini yapar ve cümle yazarının belirli bir nesneye karşı duygusal tutumunun bir değerlendirmesini elde eder.

Bu uygulamanın ana penceresi böyle görünüyor.

Duygu Analizi Web Uygulaması

Teknik açıdan, uygulama, her biri belirli bir dizi görevi çözen üç mikro hizmetten oluşur:

SA-Frontend, React statik dosyaları sunan bir Nginx web sunucusudur.
SA-WebApp, ön uçtan gelen istekleri işleyen, Java ile yazılmış bir web uygulamasıdır.
SA-Logic, metin duyarlılığı analizi yapan bir Python uygulamasıdır.

Mikro hizmetlerin tek başına bulunmadığına dikkat etmek önemlidir. "Görevler ayrılığı" fikrini uyguluyorlar ama aynı zamanda birbirleriyle etkileşime girmeleri gerekiyor.

Uygulamadaki veri akışları

Yukarıdaki diyagramda, uygulamadaki veri akışlarını gösteren, sistemin numaralandırılmış aşamalarını görebilirsiniz. Onları parçalayalım:

Tarayıcı, sunucudan bir dosya ister index.html (sırayla React uygulama paketini yükler).
Kullanıcı, uygulama ile etkileşime girer, bu, Spring tabanlı bir web uygulamasına çağrı yapılmasına neden olur.
Web uygulaması, metni ayrıştırma isteğini Python uygulamasına iletir.
Python uygulaması, metnin duyarlılığını analiz eder ve sonucu isteğe yanıt olarak döndürür.
Spring uygulaması, React uygulamasına bir yanıt gönderir (bu da kullanıcıya ayrıştırılan metnin sonucunu gösterir).

Tüm bu uygulamaların kodu bulunabilir burada. Önümüzde bununla ilgili birçok ilginç deney olduğundan, bu depoyu hemen kendinize kopyalamanızı tavsiye ederim.

Yerel makinede mikro hizmetlere dayalı bir uygulama çalıştırma

Uygulamanın çalışması için üç mikro hizmeti de başlatmamız gerekiyor. En güzelleriyle başlayalım - ön uç uygulaması.

▍Yerel geliştirme için React'i kurma

Bir React uygulamasını çalıştırmak için bilgisayarınıza Node.js çerçevesini ve NPM'yi yüklemeniz gerekir. Tüm bunları yükledikten sonra, terminali kullanarak proje klasörüne gidin. sa-frontend ve aşağıdaki komutu çalıştırın:

npm install

Klasörde bu komutu yürüterek node_modules kayıtları dosyada bulunan React uygulamasının bağımlılıkları yüklenecektir. package.json. Bağımlılıkları aynı klasöre indirdikten sonra aşağıdaki komutu çalıştırın:

npm start

Bu kadar. React uygulaması şu anda çalışıyor ve tarayıcı adresine gidilerek erişilebilir localhost:3000. Kodundaki bir şeyi değiştirebilirsiniz. Bu değişikliklerin etkisini tarayıcıda hemen göreceksiniz. Bu, modüllerin sözde "sıcak" değiştirilmesi sayesinde mümkündür. Bu sayede front-end geliştirme basit ve keyifli bir deneyime dönüşüyor.

▍Üretim için bir React uygulaması hazırlama

Bir React uygulamasını fiilen kullanmak amacıyla, onu bir dizi statik dosyaya dönüştürmemiz ve bunları bir web sunucusu kullanan istemcilere sunmamız gerekir.

Yine terminali kullanarak React uygulamasını oluşturmak için klasöre gidin sa-frontend ve aşağıdaki komutu çalıştırın:

npm run build

Bu, proje klasöründe bir dizin yaratacaktır. build. React uygulamasının çalışması için gereken tüm statik dosyaları içerecektir.

▍Statik dosyaları Nginx ile sunma

Öncelikle Nginx web sunucusunu kurmanız ve çalıştırmanız gerekir. öyle indirebilir ve yükleme ve çalıştırma talimatlarını bulabilirsiniz. Ardından klasörün içeriğini kopyalamanız gerekir. sa-frontend/build klasöre [your_nginx_installation_dir]/html.

Bu yaklaşımla, React uygulamasının derlemesi sırasında oluşturulan dosya index.html adresinde mevcut olacak [your_nginx_installation_dir]/html/index.html. Bu, varsayılan olarak Nginx sunucusunun erişirken yayınladığı dosyadır. Sunucu bir bağlantı noktasını dinleyecek şekilde yapılandırıldı 80, ancak dosyayı düzenleyerek istediğiniz şekilde özelleştirebilirsiniz. [your_nginx_installation_dir]/conf/nginx.conf.

Şimdi tarayıcınızı açın ve şu adrese gidin: localhost:80. React uygulama sayfasını göreceksiniz.

Nginx sunucusu tarafından sunulan tepki uygulaması

Şimdi alana bir şey girerseniz Type your sentence ve düğmeye basın Send - hiçbir şey olmayacak. Ancak konsola bakarsanız orada hata mesajları görebilirsiniz. Bu hataların tam olarak nerede oluştuğunu anlamak için uygulama kodunu inceleyelim.

▍Ön uç uygulama kodunun analizi

Dosyanın koduna bakıldığında App.js, butona tıklandığını görebiliriz Send bir yöntem çağırır analyzeSentence(). Bu yöntemin kodu aşağıda gösterilmiştir. Aynı zamanda, formun yorumunun bulunduğu her satır için dikkat edin. # Номер, kodun altında verilen bir açıklama var. Aynı şekilde diğer kod parçalarını da ayrıştıracağız.

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. POST isteğinin yapıldığı URL. Bu adresin, bu tür istekleri bekleyen bir uygulama olduğu varsayılmaktadır.

2.Uygulamaya gönderilen istek gövdesi. İşte örnek bir istek gövdesi:

{
    sentence: "I like yogobella!"
}

3.Bir talebe yanıt alındığında, bileşenin durumu güncellenir. Bu, bileşenin yeniden oluşturulmasına neden olur. Veri alırsak (yani, girilen verileri ve hesaplanan metin puanını içeren bir JSON nesnesi), bileşenin çıktısını alırız Polarityşartlar sağlandığı sürece. Bileşeni şu şekilde tanımlıyoruz:

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

Kod oldukça iyi çalışıyor gibi görünüyor. Burada yanlış olan ne? Uygulamanın POST isteği göndermeye çalıştığı adreste henüz bu isteği kabul edip işleyebilecek hiçbir şey olmadığını varsayarsanız, o zaman kesinlikle haklı olursunuz. Yani adrese gelen istekleri işlemek için http://localhost:8080/sentiment, Spring tabanlı bir web uygulaması çalıştırmamız gerekiyor.

POST isteğini kabul edebilecek bir Spring uygulamasına ihtiyacımız var.

▍Spring tabanlı bir web uygulaması kurma

Bir Spring uygulamasını konuşlandırmak için JDK8 ve Maven'e ve uygun şekilde yapılandırılmış ortam değişkenlerine ihtiyacınız vardır. Tüm bunları kurduktan sonra projemiz üzerinde çalışmaya devam edebilirsiniz.

▍Uygulamayı bir jar dosyasına paketleme

Terminali kullanarak klasöre gidin sa-webapp ve aşağıdaki komutu girin:

mvn install

Klasörde bu komutu yürüttükten sonra sa-webapp dizin oluşturulacak target. Bu, dosya tarafından temsil edilen bir jar dosyasında paketlenmiş Java uygulamasının yerleştirileceği yerdir. sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍Bir Java Uygulamasını Başlatma

klasöre git target ve uygulamayı aşağıdaki komutla çalıştırın:

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

Bu komut yürütülürken bir hata oluşacaktır. Düzeltmeye başlamak için, yığın izleme verilerindeki istisna ayrıntılarını ayrıştırabiliriz:

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

Bizim için burada en önemli şey, anlamın açıklığa kavuşturulmasının imkansızlığından bahsetmektir. sa.logic.api.url. Hatanın oluştuğu kodu inceleyelim.

▍Java uygulama kodu analizi

İşte hatanın oluştuğu kod parçacığı.

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

S'deentimentController bir alan var saLogicApiUrl. Değeri özellik tarafından belirlenir sa.logic.api.url.
Hat saLogicApiUrl değer ile birleştirir /analyse/sentiment. Birlikte, metin analizi yapan mikro hizmete çağrı yapmak için bir adres oluştururlar.

▍Bir özellik değeri ayarlama

İlkbaharda, özellik değerlerinin varsayılan kaynağı bir dosyadır. application.properties, şu adreste bulunabilir: sa-webapp/src/main/resources. Ancak, özellik değerlerini ayarlamanın tek yolu onu kullanmak değildir. Bunu aşağıdaki komutla da yapabilirsiniz:

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

Bu özelliğin değeri, Python uygulamamızın adresini göstermelidir.

Bunu yapılandırarak, Spring web uygulamasına metin ayrıştırma isteklerini yürütmek için nereye gitmesi gerektiğini söyleriz.

Hayatımızı zorlaştırmamak için Python uygulamasının şu adreste yer almasına karar vereceğiz: localhost:5000 ve unutmamaya çalış. Sonuç olarak, Spring uygulamasını başlatma komutu şöyle görünecektir:

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

Sistemimizde bir Python uygulaması eksik

Şimdi sadece Python uygulamasını çalıştırmamız gerekiyor ve sistem beklendiği gibi çalışacaktır.

▍Python uygulaması kurma

Bir Python uygulamasını çalıştırmak için Python 3 ve Pip'in kurulu olması ve uygun ortam değişkenlerinin doğru ayarlanmış olması gerekir.

▍Kurulum bağımlılıkları

proje klasörüne git sa-logic/sa ve aşağıdaki komutları çalıştırın:

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

▍Uygulama başlatma

Yüklenen bağımlılıklar ile uygulamayı çalıştırmaya hazırız:

python sentiment_analysis.py

Bu komutu yürüttükten sonra, bize aşağıdakiler söylenecek:

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

Bu, uygulamanın çalıştığı ve şu adreste istekleri beklediği anlamına gelir: localhost:5000/

▍Kod araştırması

İsteklere nasıl yanıt verdiğini anlamak için Python uygulama koduna bakalım:

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

nesne başlatma Flask.
POST istekleri yapmak için adresin belirtilmesi.
Bir mülkün alınması sentence istek gövdesinden.
Anonim nesne başlatma TextBlob ve değeri almak polarity talep metninde alınan ilk teklif için (bizim durumumuzda bu, analiz için sunulan tek tekliftir).
Gövdesi teklifin metnini ve bunun için hesaplanan göstergeyi içeren bir yanıt döndürme polarity.
adresinde mevcut olacak olan Flask uygulamasını başlatma 0.0.0.0:5000 (formun yapısını kullanarak da erişebilirsiniz. localhost:5000).

Artık uygulamayı oluşturan mikro hizmetler çalışıyor. Birbirleriyle etkileşime girecek şekilde ayarlanmıştır. Uygulama şeması işin bu aşamasında böyle görünüyor.

Uygulamayı oluşturan tüm mikro hizmetler sağlıklı bir duruma getirilir.

Şimdi, devam etmeden önce, React uygulamasını bir tarayıcıda açın ve onunla bazı cümleleri ayrıştırmayı deneyin. Her şey doğru yapılırsa - düğmeye bastıktan sonra Send metin kutusunun altında analiz sonuçlarını göreceksiniz.

Bir sonraki bölümde, mikro servislerimizi Docker kapsayıcılarında nasıl çalıştıracağımızdan bahsedeceğiz. Bu, uygulamayı Kubernetes kümesinde çalışacak şekilde hazırlamak için gereklidir.

Docker konteynerleri

Kubernetes kapsayıcılı uygulamaların dağıtımını, ölçeklendirmesini ve yönetimini otomatikleştirmeye yönelik bir sistemdir. Aynı zamanda "kapsayıcı düzenleyici" olarak da adlandırılır. Kubernetes, container'larla çalışıyorsa bu sistemi kullanmadan önce öncelikle bu container'ları edinmemiz gerekiyor. Ama önce konteynerlerin ne olduğundan bahsedelim. Nedir sorusuna belki de en iyi cevap bu yazıda bulunabilir. belgeleme Docker'a:

Kapsayıcı görüntüsü, onu çalıştırmak için gereken her şeyi içeren bir uygulamayı içeren hafif, bağımsız, yürütülebilir bir pakettir: uygulama kodu, çalışma zamanı ortamı, sistem araçları ve kitaplıklar, ayarlar. Kapsayıcılı programlar hem Linux hem de Windows ortamlarında kullanılabilir ve altyapıdan bağımsız olarak her zaman aynı şekilde çalışır.

Bu, konteynerlerin üretim sunucuları da dahil olmak üzere herhangi bir bilgisayarda çalıştırılabileceği ve bunlara dahil edilen uygulamaların herhangi bir ortamda aynı şekilde çalışacağı anlamına gelir.

Konteynerlerin özelliklerini keşfetmek ve uygulamaları çalıştırmanın diğer yollarıyla karşılaştırmak için, bir sanal makine ve bir konteyner kullanarak bir React uygulaması sunma örneğine bakalım.

▍Bir sanal makine kullanarak bir React uygulamasının statik dosyalarını sunma

Statik dosyaların bakımını sanal makineler kullanarak organize etmeye çalışırken aşağıdaki dezavantajlarla karşılaşacağız:

Her bir sanal makine eksiksiz bir işletim sistemi olduğu için kaynakların verimsiz kullanımı.
Platform bağımlılığı. Bazı yerel bilgisayarlarda çalışan bir şey, bir üretim sunucusunda çalışmayabilir.
Bir sanal makine çözümünün yavaş ve yoğun kaynak kullanımı.

Sanal bir makinede çalışan statik dosyalara hizmet veren Nginx web sunucusu

Benzer bir sorunu çözmek için kaplar kullanılıyorsa, sanal makinelerle karşılaştırıldığında aşağıdaki güçlü yönler not edilebilir:

Kaynakların verimli kullanımı: Docker kullanarak işletim sistemiyle çalışın.
Platform bağımsızlığı. Bir geliştiricinin kendi bilgisayarında çalıştırabileceği bir container her yerde çalışır.
Görüntü katmanlarının kullanımıyla hafif dağıtım.

Bir kapta çalışan statik dosyalara hizmet veren Nginx web sunucusu

Sanal makineleri ve kapsayıcıları yalnızca birkaç noktada karşılaştırdık, ancak bu bile kapsayıcıların güçlü yönleri hakkında fikir sahibi olmak için yeterli. öyle Docker kapsayıcıları ile ilgili ayrıntıları burada bulabilirsiniz.

▍Bir React uygulaması için kapsayıcı görüntüsü oluşturma

Bir Docker kapsayıcısının temel yapı taşı dosyadır. Dockerfile. Bu dosyanın başında, kabın temel bir görüntüsü kaydedilir, ardından bir uygulamanın ihtiyaçlarını karşılayacak bir kabın nasıl oluşturulacağını gösteren bir dizi talimat eklenir.

Dosyayla çalışmaya başlamadan önce Dockerfile, React uygulamasının dosyalarını Nginx sunucusuna yüklemek üzere hazırlamak için ne yaptığımızı hatırlayın:

Bir React uygulama paketi oluşturma (npm run build).
Nginx sunucusunu başlatma.
Bir dizinin içeriğini kopyalama build proje klasöründen sa-frontend sunucu klasörüne nginx/html.

Aşağıda, kapsayıcı oluşturma ile yerel bilgisayarda gerçekleştirilen yukarıdaki eylemler arasındaki paralellikleri görebilirsiniz.

▍SA-Frontend Uygulaması için Dockerfile Hazırlama

Eklenecek talimatlar Dockerfile uygulama için SA-Frontend, yalnızca iki komuttan oluşur. Gerçek şu ki, Nginx geliştirme ekibi temel bir образ imajımızı oluşturmak için kullanacağımız Nginx için. İşte açıklamamız gereken iki adım:

Nginx görüntüsünü görüntünün temeli haline getirmeniz gerekir.
Klasör içeriği sa-frontend/build resim klasörüne kopyalamanız gerekiyor nginx/html.

Bu açıklamadan dosyaya gidersek Dockerfile, sonra şöyle görünecektir:

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

Gördüğünüz gibi, burada her şey çok basit, dosyanın içeriği bile oldukça okunabilir ve anlaşılır. Bu dosya sisteme görüntüyü almasını söyler. nginx zaten sahip olduğu her şeyle ve dizinin içeriğini kopyalayın build dizine nginx/html.

Burada, dosyaları klasörden tam olarak nereye kopyalayacağımı nasıl bildiğimle ilgili bir sorunuz olabilir. build, yani yol nereden geldi /usr/share/nginx/html. Aslında burada da karmaşık bir şey yok. Gerçek şu ki, ilgili bilgiler şurada bulunabilir: Tanım görüntü.

▍Görüntünün birleştirilmesi ve depoya yüklenmesi

Tamamlanmış bir görüntüyle çalışmadan önce, onu görüntü deposuna göndermemiz gerekir. Bunu yapmak için, ücretsiz bulut tabanlı görüntü barındırma platformu Docker Hub'ı kullanacağız. İşin bu aşamasında aşağıdakileri yapmanız gerekir:

kurmak liman işçisi.
Docker Hub sitesine kaydolun.
Terminalde aşağıdaki komutu çalıştırarak hesabınıza giriş yapın:
```
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
```

Şimdi terminali kullanarak dizine gitmeniz gerekiyor. sa-frontend ve orada aşağıdaki komutu çalıştırın:

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

Burada ve aşağıda benzer komutlarda $DOCKER_USER_ID Docker Hub'daki kullanıcı adınızla değiştirilmelidir. Örneğin, komutun bu kısmı şöyle görünebilir: rinormaloku/sentiment-analysis-frontend.

Bu durumda, bu komut ondan çıkarılarak kısaltılabilir. -f Dockerfile, çünkü bu komutu yürüttüğümüz klasörde zaten bu dosya var.

Bitmiş görüntüyü depoya göndermek için aşağıdaki komuta ihtiyacımız var:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

Tamamladıktan sonra, görüntünün bulut depolamaya başarıyla aktarılıp aktarılmadığını görmek için Docker Hub'daki havuz listenizi kontrol edin.

▍Konteyner başlatma

Artık herkes, olarak bilinen görüntüyü indirip çalıştırabilir. $DOCKER_USER_ID/sentiment-analysis-frontend. Bunu yapmak için aşağıdaki komut dizisini çalıştırmanız gerekir:

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

Artık container çalışıyor ve ihtiyacımız olan diğer imajları oluşturarak çalışmaya devam edebiliriz. Ancak devam etmeden önce tasarımı anlayalım 80:80, görüntüyü çalıştırma komutunda bulunur ve kafa karıştırıcı görünebilir.

İlk numara 80 ana bilgisayarın (yani yerel bilgisayarın) bağlantı noktası numarasıdır.
ikinci sayı 80 isteğin yeniden yönlendirilmesi gereken konteynerin bağlantı noktasıdır.

Aşağıdaki çizimi göz önünde bulundurun.

Port Yönlendirme

Sistem, istekleri bağlantı noktasından iletir <hostPort> bağlantı noktası başına <containerPort>. Yani, bağlantı noktasına erişim 80 bilgisayar bir bağlantı noktasına yönlendirilir 80 konteyner.

limandan beri 80 yerel bilgisayarda açıldıysa, bu bilgisayardan uygulamaya şu adresten erişebilirsiniz: localhost:80. Sisteminiz Docker'ı desteklemiyorsa, uygulamayı adresi şöyle görünecek olan bir Docker sanal makinesinde çalıştırabilirsiniz. <docker-machine ip>:80. Docker sanal makinesinin IP adresini öğrenmek için aşağıdaki komutu kullanabilirsiniz. docker-machine ip.

Bu noktada, ön uç uygulama kabı başarıyla başlatıldıktan sonra, sayfasını bir tarayıcıda açabilmelisiniz.

▍.dockerignore dosyası

Uygulama görüntüsünü oluşturma SA-Frontend, bu sürecin son derece yavaş olduğunu fark edebiliriz. Bunun nedeni, görüntü oluşturma bağlamının Docker arka plan programına gönderilmesi gerekmesidir. Derleme bağlamını temsil eden dizin, komutun son argümanı olarak verilir. docker build. Bizim durumumuzda bu komutun sonunda bir nokta var. Bu, aşağıdaki yapının montaj bağlamına dahil edilmesiyle sonuçlanır:

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

Ancak burada bulunan tüm klasörlerden yalnızca bir klasöre ihtiyacımız var. build. Başka bir şey indirmek zaman kaybıdır. Docker'a hangi dizinlerin yoksayılacağını söyleyerek derlemeyi hızlandırabilirsiniz. Bunu yapmak için bir dosyaya ihtiyacımız var. .dockerignore. Siz, dosyaya aşina iseniz .gitignore, bu dosyanın yapısı muhtemelen tanıdık gelecektir. Görüntü oluşturma sisteminin yoksayabileceği dizinleri listeler. Bizim durumumuzda, bu dosyanın içeriği şöyle görünür:

node_modules
src
public

Dosya .dockerignore dosya ile aynı klasörde olmalıdır Dockerfile. Şimdi görüntünün montajı birkaç saniye sürecek.

Şimdi bir Java uygulaması için image ile ilgilenelim.

▍Bir Java uygulaması için kapsayıcı görüntüsü oluşturma

Biliyor musun ve kapsayıcı görüntüleri oluşturmak için ihtiyacın olan her şeyi zaten öğrendin. Bu yüzden bu bölüm çok kısa olacak.

Dosyayı aç Dockerfile, proje klasöründe bulunur sa-webapp. Bu dosyanın metnini okursanız, içinde anahtar sözcüklerle başlayan yalnızca iki yeni yapıyla tanışacaksınız. ENV и EXPOSE:

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

Kelimeler ENV Docker kapsayıcıları içindeki ortam değişkenlerini bildirmenize olanak tanır. Özellikle bizim durumumuzda, metin analizi yapan uygulamanın API'sine erişmek için bir URL ayarlamanıza olanak tanır.

Kelimeler EXPOSE Docker'a bir bağlantı noktası açmasını söylemenizi sağlar. Uygulama ile çalışırken bu portu kullanacağız. Burada bunu görebilirsiniz Dockerfile uygulama için SA-Frontend böyle bir komut yok. Bu sadece dokümantasyon amaçlıdır, başka bir deyişle bu yapı okuyucu içindir. Dockerfile.

Görüntüyü oluşturmak ve onu depoya göndermek tam olarak önceki örneğe benziyor. Henüz yeteneklerinize çok güvenmiyorsanız, ilgili komutlar dosyada bulunabilir. README.md klasörde sa-webapp.

▍Python uygulaması için kapsayıcı görüntüsü oluşturma

Dosyanın içeriğine bakarsanız Dockerfile klasörde sa-logicorada yeni bir şey bulamayacaksın. Görüntüyü oluşturma ve depoya gönderme komutları da size aşina olmalıdır, ancak diğer uygulamalarımızda olduğu gibi, bunlar dosyada bulunabilir. README.md klasörde sa-logic.

▍Kapsayıcılı uygulamaları test etme

Test etmediğiniz bir şeye güvenebilir misiniz? Ben de yapamam. Konteynerlerimizi test edelim.

Uygulama kapsayıcısını başlatalım sa-logic ve bir bağlantı noktasını dinleyecek şekilde yapılandırın 5050:
```
docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic
```
Uygulama kapsayıcısını başlatalım sa-webapp ve bir bağlantı noktasını dinleyecek şekilde yapılandırın 8080. Ek olarak, ortam değişkenini yeniden atayarak Python uygulamasının Java uygulamasından gelen istekleri dinleyeceği bağlantı noktasını ayarlamamız gerekir. 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
```

Bir kapsayıcının veya Docker VM'nin IP adresini nasıl bulacağınızı öğrenmek için dosyaya bakın. README.

Uygulama kapsayıcısını başlatalım sa-frontend:

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

Artık tarayıcıda adrese gitmek için her şey hazır localhost:80 ve uygulamayı test edin.

için bağlantı noktasını değiştirirseniz lütfen unutmayın. sa-webappveya bir Docker VM çalıştırıyorsanız, dosyayı düzenlemeniz gerekir App.js bir klasörden sa-frontendyöntemdeki IP adresini veya bağlantı noktası numarasını değiştirerek analyzeSentence()Eski veriler yerine güncel bilgileri kullanarak. Bundan sonra, görüntüyü yeniden birleştirmeniz ve kullanmanız gerekir.

Uygulama şemamız şimdi böyle görünüyor.

Kapsayıcılarda çalışan mikro hizmetler

Özet: neden bir Kubernetes kümesine ihtiyacımız var?

Dosyaları yeni inceledik Dockerfile, görüntülerin nasıl oluşturulacağı ve bunların bir Docker deposuna nasıl gönderileceği hakkında konuştu. Ek olarak, dosyayı kullanarak görüntülerin montajını nasıl hızlandıracağımızı öğrendik. .dockerignore. Sonuç olarak, mikro hizmetlerimiz artık Docker kapsayıcılarında çalışıyor. Burada neden Kubernetes'e ihtiyacımız olduğuna dair tamamen haklı bir sorunuz olabilir. Bu sorunun cevabı, bu materyalin ikinci bölümüne ayrılacaktır. Bu arada, şu soruyu düşünün:
Metin analizi web uygulamamızın dünya çapında popüler olduğunu varsayalım. Ona her dakika milyonlarca istek geliyor. Bu, mikro hizmetlerin sa-webapp и sa-logic büyük bir stres altında olacak. Mikro hizmetleri çalıştıran kapsayıcılar nasıl ölçeklendirilir?

Kaynak: habr.com

Kubernetes Eğitimi 1. Bölüm: Uygulamalar, Mikro Hizmetler ve Kapsayıcılar