కుబెర్నెటెస్ ట్యుటోరియల్ పార్ట్ 1: అప్లికేషన్‌లు, మైక్రోసర్వీసెస్ మరియు కంటైనర్‌లు

మా అభ్యర్థన మేరకు, Habr ఒక హబ్‌ని సృష్టించారు Kubernetes మరియు దానిలో మొదటి ప్రచురణను ఉంచడానికి మేము సంతోషిస్తున్నాము. సభ్యత్వం పొందండి!

కుబెర్నెటెస్ సులభం. ఈ ప్రాంతంలో పని చేయడానికి బ్యాంకులు నాకు చాలా డబ్బు ఎందుకు చెల్లిస్తాయి, అయితే ఎవరైనా ఈ సాంకేతికతను కేవలం కొన్ని గంటల్లోనే నైపుణ్యం చేయగలరు?

కుబెర్నెట్స్‌ని ఇంత త్వరగా నేర్చుకోగలరా అని మీకు అనుమానం ఉంటే, మీరే ప్రయత్నించమని నేను సూచిస్తున్నాను. అవి, ఈ మెటీరియల్‌లో ప్రావీణ్యం సంపాదించిన తర్వాత, మీరు కుబెర్నెట్స్ క్లస్టర్‌లో మైక్రోసర్వీస్ ఆధారంగా అప్లికేషన్‌ను అమలు చేయగలరు. నేను మా క్లయింట్‌లకు కుబెర్నెట్స్‌తో కలిసి పని చేయడానికి బోధించడానికి ఇక్కడ ఉపయోగించిన అదే పద్దతి కాబట్టి నేను దీనికి హామీ ఇవ్వగలను. ఈ మార్గదర్శిని ఇతరులకు భిన్నంగా ఏమి చేస్తుంది? నిజానికి, చాలా విషయాలు ఉన్నాయి. కాబట్టి, ఈ మెటీరియల్స్ చాలా వరకు సాధారణ విషయాల వివరణతో ప్రారంభమవుతాయి - కుబెర్నెట్స్ యొక్క భావనలు మరియు kubectl కమాండ్ యొక్క లక్షణాలు. ఈ మెటీరియల్‌ల రచయితలు తమ పాఠకులకు అప్లికేషన్ డెవలప్‌మెంట్, మైక్రోసర్వీసెస్ మరియు డాకర్ కంటైనర్‌ల గురించి బాగా తెలుసునని ఊహిస్తారు. మేము వేరే మార్గంలో వెళ్తాము. ముందుగా, కంప్యూటర్‌లో మైక్రోసర్వీస్ ఆధారంగా అప్లికేషన్‌ను ఎలా అమలు చేయాలనే దాని గురించి మాట్లాడుతాము. అప్పుడు మేము ప్రతి మైక్రోసర్వీస్ కోసం కంటైనర్ చిత్రాలను నిర్మించడాన్ని పరిశీలిస్తాము. మరియు ఆ తర్వాత, మేము Kubernetesతో పరిచయం పొందుతాము మరియు Kubernetes ద్వారా నిర్వహించబడే క్లస్టర్‌లో మైక్రోసర్వీస్‌ల ఆధారంగా ఒక అప్లికేషన్‌ని అమలు చేయడాన్ని పరిశీలిస్తాము.

ఈ విధానం, కుబెర్నెటెస్‌కు క్రమంగా విధానంతో, కుబెర్నెట్స్‌లో ప్రతిదీ ఎంత సరళంగా పనిచేస్తుందో అర్థం చేసుకోవడానికి సగటు వ్యక్తికి ఏమి జరుగుతుందో అర్థం చేసుకోవడానికి లోతుగా ఉంటుంది. Kubernetes ఖచ్చితంగా ఒక సాధారణ సాంకేతికత, ఇది ఎక్కడ మరియు ఎలా ఉపయోగించబడుతుందో తెలుసుకోవాలనుకునే వారికి అందించబడుతుంది.

ఇప్పుడు, మరింత శ్రమ లేకుండా, ప్రారంభించి, మనం పని చేయబోయే అప్లికేషన్ గురించి మాట్లాడుకుందాం.

ప్రయోగాత్మక అప్లికేషన్

మా అప్లికేషన్ ఒక ఫంక్షన్ మాత్రమే చేస్తుంది. ఇది ఒక వాక్యాన్ని ఇన్‌పుట్‌గా తీసుకుంటుంది, దాని తర్వాత, టెక్స్ట్ విశ్లేషణ సాధనాలను ఉపయోగించి, ఇది ఈ వాక్యం యొక్క సెంటిమెంట్ విశ్లేషణను నిర్వహిస్తుంది, ఒక నిర్దిష్ట వస్తువుకు వాక్యం యొక్క రచయిత యొక్క భావోద్వేగ వైఖరిని అంచనా వేస్తుంది.

ఈ అప్లికేషన్ యొక్క ప్రధాన విండో ఇలా కనిపిస్తుంది.

టెక్స్ట్‌ల సెంటిమెంట్ విశ్లేషణ కోసం వెబ్ అప్లికేషన్

సాంకేతిక కోణం నుండి, అప్లికేషన్ మూడు మైక్రోసర్వీస్‌లను కలిగి ఉంటుంది, వీటిలో ప్రతి ఒక్కటి నిర్దిష్ట సమస్యలను పరిష్కరిస్తుంది:

• SA-Frontend అనేది స్టాటిక్ రియాక్ట్ ఫైల్‌లను అందించే Nginx వెబ్ సర్వర్.
• SA-WebApp అనేది జావాలో వ్రాయబడిన వెబ్ అప్లికేషన్, ఇది ఫ్రంటెండ్ నుండి అభ్యర్థనలను ప్రాసెస్ చేస్తుంది.
• SA-Logic అనేది టెక్స్ట్‌పై సెంటిమెంట్ విశ్లేషణ చేసే పైథాన్ అప్లికేషన్.

మైక్రోసర్వీస్‌లు ఒంటరిగా ఉండవని గమనించడం ముఖ్యం. వారు "బాధ్యతలను వేరు చేయడం" అనే ఆలోచనను అమలు చేస్తారు, కానీ అదే సమయంలో వారు ఒకరితో ఒకరు సంభాషించాల్సిన అవసరం ఉంది.

అప్లికేషన్‌లో డేటా ప్రవహిస్తుంది

ఎగువ రేఖాచిత్రంలో, మీరు అప్లికేషన్‌లోని డేటా ప్రవాహాలను వివరిస్తూ సిస్టమ్ యొక్క సంఖ్యా దశలను చూడవచ్చు. వాటిని చూద్దాం:

1. బ్రౌజర్ సర్వర్ నుండి ఫైల్‌ను అభ్యర్థిస్తుంది index.html (ఇది రియాక్ట్ అప్లికేషన్ ప్యాకేజీని డౌన్‌లోడ్ చేస్తుంది).
2. వినియోగదారు అప్లికేషన్‌తో పరస్పర చర్య చేస్తారు, ఇది స్ప్రింగ్-ఆధారిత వెబ్ అప్లికేషన్‌కి కాల్ చేస్తుంది.
3. వెబ్ అప్లికేషన్ టెక్స్ట్ విశ్లేషణను నిర్వహించడానికి అభ్యర్థనను పైథాన్ అప్లికేషన్‌కు ఫార్వార్డ్ చేస్తుంది.
4. పైథాన్ అప్లికేషన్ టెక్స్ట్ యొక్క సెంటిమెంట్ విశ్లేషణను నిర్వహిస్తుంది మరియు అభ్యర్థనకు ప్రతిస్పందనగా ఫలితాన్ని అందిస్తుంది.
5. స్ప్రింగ్ అప్లికేషన్ రియాక్ట్ అప్లికేషన్‌కు ప్రతిస్పందనను పంపుతుంది (ఇది వినియోగదారుకు వచన విశ్లేషణ ఫలితాన్ని చూపుతుంది).

ఈ అన్ని అప్లికేషన్‌ల కోడ్‌ను కనుగొనవచ్చు ఇక్కడ. ఈ రిపోజిటరీని ఇప్పుడు మీ కోసం కాపీ చేయమని నేను సిఫార్సు చేస్తున్నాను, ఎందుకంటే దానితో చాలా ఆసక్తికరమైన ప్రయోగాలు మన ముందు ఉన్నాయి.

మీ స్థానిక మెషీన్‌లో మైక్రోసర్వీస్-ఆధారిత అప్లికేషన్‌ను అమలు చేస్తోంది

అప్లికేషన్ పని చేయడానికి, మేము మూడు మైక్రోసర్వీస్‌లను ప్రారంభించాలి. వాటిలో అత్యంత అందమైనది - ఫ్రంట్-ఎండ్ అప్లికేషన్‌తో ప్రారంభిద్దాం.

▍స్థానిక అభివృద్ధి కోసం రియాక్ట్‌ని సెటప్ చేయండి

రియాక్ట్ అప్లికేషన్‌ను అమలు చేయడానికి, మీరు మీ కంప్యూటర్‌లో Node.js ప్లాట్‌ఫారమ్ మరియు NPMని ఇన్‌స్టాల్ చేయాలి. మీరు ఇవన్నీ ఇన్‌స్టాల్ చేసిన తర్వాత, మీ ప్రాజెక్ట్ ఫోల్డర్‌కి నావిగేట్ చేయడానికి టెర్మినల్‌ని ఉపయోగించండి sa-frontend మరియు కింది ఆదేశాన్ని అమలు చేయండి:

npm install

ఫోల్డర్‌లో ఈ ఆదేశాన్ని అమలు చేయడం ద్వారా node_modules రియాక్ట్ అప్లికేషన్ యొక్క డిపెండెన్సీలు లోడ్ చేయబడతాయి, వాటి రికార్డులు ఫైల్‌లో ఉంటాయి package.json. డిపెండెన్సీలను ఒకే ఫోల్డర్‌లో డౌన్‌లోడ్ చేసిన తర్వాత, కింది ఆదేశాన్ని అమలు చేయండి:

npm start

అంతే. ఇప్పుడు రియాక్ట్ అప్లికేషన్ రన్ అవుతోంది, మీరు మీ బ్రౌజర్‌లోని క్రింది చిరునామాకు వెళ్లడం ద్వారా దాన్ని యాక్సెస్ చేయవచ్చు: localhost:3000. మీరు దాని కోడ్‌లో ఏదైనా మార్చవచ్చు. బ్రౌజర్‌లో ఈ మార్పుల ప్రభావాన్ని మీరు వెంటనే చూస్తారు. మాడ్యూల్స్ యొక్క "హాట్" భర్తీ అని పిలవబడే కృతజ్ఞతలు ఇది సాధ్యమవుతుంది. ఇది ఫ్రంట్-ఎండ్ డెవలప్‌మెంట్‌ను సరళమైన మరియు ఆనందించే అనుభవంగా చేస్తుంది.

▍ఉత్పత్తి కోసం రియాక్ట్ అప్లికేషన్‌ను సిద్ధం చేస్తోంది

వాస్తవానికి రియాక్ట్ అప్లికేషన్‌ను ఉపయోగించడం కోసం, మేము దానిని స్టాటిక్ ఫైల్‌ల సెట్‌గా మార్చాలి మరియు వాటిని వెబ్ సర్వర్‌ని ఉపయోగించి క్లయింట్‌లకు అందించాలి.

రియాక్ట్ అప్లికేషన్‌ను రూపొందించడానికి, మళ్లీ టెర్మినల్‌ని ఉపయోగించి, ఫోల్డర్‌కి నావిగేట్ చేయండి sa-frontend మరియు కింది ఆదేశాన్ని అమలు చేయండి:

npm run build

ఇది ప్రాజెక్ట్ ఫోల్డర్‌లో డైరెక్టరీని సృష్టిస్తుంది build. ఇది రియాక్ట్ అప్లికేషన్ పని చేయడానికి అవసరమైన అన్ని స్టాటిక్ ఫైల్‌లను కలిగి ఉంటుంది.

▍Nginxని ఉపయోగించి స్టాటిక్ ఫైల్‌లను అందిస్తోంది

మొదట మీరు Nginx వెబ్ సర్వర్‌ను ఇన్‌స్టాల్ చేసి అమలు చేయాలి. ఇది మీరు దీన్ని డౌన్‌లోడ్ చేసుకోవచ్చు మరియు దీన్ని ఎలా ఇన్‌స్టాల్ చేయాలి మరియు రన్ చేయాలి అనే దానిపై సూచనలను కనుగొనవచ్చు. అప్పుడు మీరు ఫోల్డర్ యొక్క కంటెంట్లను కాపీ చేయాలి sa-frontend/build ఫోల్డర్‌కు [your_nginx_installation_dir]/html.

ఈ విధానంతో, రియాక్ట్ అప్లికేషన్ యొక్క బిల్డ్ ప్రాసెస్ సమయంలో రూపొందించబడిన ఫైల్ index.html వద్ద అందుబాటులో ఉంటుంది [your_nginx_installation_dir]/html/index.html. ఇది డిఫాల్ట్‌గా, Nginx సర్వర్‌ని యాక్సెస్ చేస్తున్నప్పుడు ఉత్పత్తి చేసే ఫైల్. పోర్ట్‌లో వినడానికి సర్వర్ కాన్ఫిగర్ చేయబడింది 80, కానీ ఫైల్‌ను సవరించడం ద్వారా మీకు అవసరమైన విధంగా అనుకూలీకరించవచ్చు [your_nginx_installation_dir]/conf/nginx.conf.

ఇప్పుడు మీ బ్రౌజర్‌ని తెరిచి, వెళ్ళండి localhost:80. మీరు రియాక్ట్ అప్లికేషన్ పేజీని చూస్తారు.

Nginx సర్వర్ అందించిన రియాక్ట్ అప్లికేషన్

మీరు ఇప్పుడు ఏదైనా రంగంలోకి ప్రవేశిస్తే Type your sentence మరియు బటన్ నొక్కండి Send - ఏమీ జరగదు. కానీ, మీరు కన్సోల్‌ను చూస్తే, మీరు అక్కడ దోష సందేశాలను చూడవచ్చు. ఈ లోపాలు సరిగ్గా ఎక్కడ జరుగుతాయో అర్థం చేసుకోవడానికి, అప్లికేషన్ కోడ్‌ను విశ్లేషిద్దాం.

▍ఫ్రంట్-ఎండ్ అప్లికేషన్ కోడ్ విశ్లేషణ

ఫైల్ కోడ్‌ని పరిశీలించడం App.js, బటన్‌ను నొక్కడం మనం చూడవచ్చు Send ఒక పద్ధతిని పిలుస్తుంది analyzeSentence(). ఈ పద్ధతికి సంబంధించిన కోడ్ క్రింద ఇవ్వబడింది. ఫారమ్ యొక్క వ్యాఖ్యను కలిగి ఉన్న ప్రతి పంక్తికి దయచేసి గమనించండి # Номер, కోడ్ క్రింద ఇవ్వబడిన వివరణ ఉంది. మేము ఇతర కోడ్ శకలాలను అదే విధంగా విశ్లేషిస్తాము.

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

1. POST అభ్యర్థన చేయబడిన URL. అటువంటి అభ్యర్థనలను ఆశించే అప్లికేషన్ ఈ చిరునామాలో ఉందని భావించబడుతుంది.

2.అభ్యర్థన శరీరం దరఖాస్తుకు పంపబడింది. ఇక్కడ ఒక ఉదాహరణ అభ్యర్థన బాడీ ఉంది:

{
    sentence: "I like yogobella!"
}

3.అభ్యర్థనకు ప్రతిస్పందన వచ్చినప్పుడు, భాగం యొక్క స్థితి నవీకరించబడుతుంది. దీని వలన కాంపోనెంట్ రీ-రెండర్ అవుతుంది. మేము డేటాను స్వీకరిస్తే (అంటే, ఇన్‌పుట్ డేటా మరియు లెక్కించిన టెక్స్ట్ స్కోర్‌ను కలిగి ఉన్న JSON ఆబ్జెక్ట్), మేము కాంపోనెంట్‌ను అవుట్‌పుట్ చేస్తాము Polarity, తగిన షరతులు నెరవేరుతాయి కాబట్టి. మేము ఈ భాగాన్ని వివరిస్తాము:

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

కోడ్ బాగా పని చేస్తున్నట్లు కనిపిస్తోంది. అయినా ఇందులో తప్పేముంది? అప్లికేషన్ POST అభ్యర్థనను పంపడానికి ప్రయత్నిస్తున్న చిరునామాలో, ఈ అభ్యర్థనను ఆమోదించడానికి మరియు ప్రాసెస్ చేయడానికి ఇంకా ఏదీ లేదని మీరు అనుకుంటే, మీరు ఖచ్చితంగా సరైనది అవుతారు. అవి, వద్ద స్వీకరించిన అభ్యర్థనలను ప్రాసెస్ చేయడానికి http://localhost:8080/sentiment, మేము స్ప్రింగ్ ఆధారంగా వెబ్ అప్లికేషన్‌ను అమలు చేయాలి.

POST అభ్యర్థనను ఆమోదించగల స్ప్రింగ్ అప్లికేషన్ మాకు అవసరం

▍స్ప్రింగ్ ఆధారిత వెబ్ అప్లికేషన్‌ను సెటప్ చేయడం

స్ప్రింగ్ అప్లికేషన్‌ను అమలు చేయడానికి, మీకు JDK8 మరియు మావెన్ మరియు సరిగ్గా కాన్ఫిగర్ చేయబడిన ఎన్విరాన్‌మెంట్ వేరియబుల్స్ అవసరం. మీరు ఇవన్నీ ఇన్‌స్టాల్ చేసిన తర్వాత, మీరు మా ప్రాజెక్ట్‌లో పని చేయడం కొనసాగించవచ్చు.

▍అప్లికేషన్‌ను జార్ ఫైల్‌లో ప్యాకేజింగ్ చేయడం

టెర్మినల్‌ని ఉపయోగించి ఫోల్డర్‌కి నావిగేట్ చేయండి sa-webapp మరియు కింది ఆదేశాన్ని నమోదు చేయండి:

mvn install

ఫోల్డర్‌లో ఈ ఆదేశాన్ని అమలు చేసిన తర్వాత sa-webapp ఒక డైరెక్టరీ సృష్టించబడుతుంది target. ఫైల్ ద్వారా ప్రాతినిధ్యం వహించే జావా అప్లికేషన్ ఇక్కడే జార్ ఫైల్‌లో ప్యాక్ చేయబడుతుంది sentiment-analysis-web-0.0.1-SNAPSHOT.jar.

▍జావా అప్లికేషన్‌ను అమలు చేస్తోంది

ఫోల్డర్‌కి వెళ్లండి target మరియు కింది ఆదేశంతో అప్లికేషన్‌ను అమలు చేయండి:

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

ఈ ఆదేశాన్ని అమలు చేస్తున్నప్పుడు లోపం సంభవిస్తుంది. దాన్ని పరిష్కరించడం ప్రారంభించడానికి, మేము స్టాక్ ట్రేస్ డేటాలోని మినహాయింపు వివరాలను విశ్లేషించవచ్చు:

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

మాకు, ఇక్కడ చాలా ముఖ్యమైన విషయం ఏమిటంటే అర్థాన్ని స్పష్టం చేయడం అసంభవం sa.logic.api.url. లోపం సంభవించే కోడ్‌ను విశ్లేషిద్దాం.

▍జావా అప్లికేషన్ కోడ్ విశ్లేషణ

లోపం సంభవించే కోడ్ స్నిప్పెట్ ఇక్కడ ఉంది.

@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. ఎస్ లోentimentController ఒక క్షేత్రం ఉంది saLogicApiUrl. దీని విలువ ఆస్తి ద్వారా నిర్దేశించబడుతుంది sa.logic.api.url.
2. వరుసగా saLogicApiUrl విలువతో కలుస్తుంది /analyse/sentiment. వారు కలిసి టెక్స్ట్ విశ్లేషణ చేసే మైక్రోసర్వీస్‌కు కాల్ చేయడానికి చిరునామాను ఏర్పరుస్తారు.

▍ఆస్తి విలువను సెట్ చేయండి

వసంతకాలంలో, ఆస్తి విలువల యొక్క ప్రామాణిక మూలం ఫైల్ application.properties, వద్ద కనుగొనవచ్చు sa-webapp/src/main/resources. కానీ ఆస్తి విలువలను సెట్ చేయడానికి దాని ఉపయోగం మాత్రమే మార్గం కాదు. కింది ఆదేశాన్ని ఉపయోగించి కూడా ఇది చేయవచ్చు:

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

ఈ ఆస్తి విలువ మా పైథాన్ అప్లికేషన్ చిరునామాను సూచించాలి.

దీన్ని కాన్ఫిగర్ చేయడం ద్వారా, టెక్స్ట్ విశ్లేషణ అభ్యర్థనలను నిర్వహించడానికి స్ప్రింగ్ వెబ్ అప్లికేషన్ ఎక్కడికి వెళ్లాలో మేము తెలియజేస్తాము.

మన జీవితాన్ని క్లిష్టతరం చేయకుండా ఉండటానికి, పైథాన్ అప్లికేషన్ అందుబాటులో ఉంటుందని మేము నిర్ణయిస్తాము localhost:5000 మరియు దాని గురించి మరచిపోకుండా ప్రయత్నిద్దాం. ఫలితంగా, స్ప్రింగ్ అప్లికేషన్‌ను ప్రారంభించే ఆదేశం ఇలా కనిపిస్తుంది:

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

మా సిస్టమ్‌లో పైథాన్ అప్లికేషన్ లేదు

ఇప్పుడు మనం చేయాల్సిందల్లా పైథాన్ అప్లికేషన్‌ను అమలు చేయండి మరియు సిస్టమ్ ఊహించిన విధంగా పని చేస్తుంది.

▍పైథాన్ అప్లికేషన్‌ను సెటప్ చేస్తోంది

పైథాన్ అప్లికేషన్‌ను అమలు చేయడానికి, మీరు తప్పనిసరిగా పైథాన్ 3 మరియు పిప్‌ని ఇన్‌స్టాల్ చేసి ఉండాలి మరియు తగిన ఎన్విరాన్‌మెంట్ వేరియబుల్స్ సరిగ్గా సెట్ చేయబడాలి.

▍డిపెండెన్సీలను ఇన్‌స్టాల్ చేస్తోంది

మీ ప్రాజెక్ట్ ఫోల్డర్‌కి వెళ్లండి sa-logic/sa మరియు కింది ఆదేశాలను అమలు చేయండి:

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

▍అప్లికేషన్‌ను ప్రారంభించండి

డిపెండెన్సీలను ఇన్‌స్టాల్ చేసిన తర్వాత, మేము అప్లికేషన్‌ను అమలు చేయడానికి సిద్ధంగా ఉన్నాము:

python sentiment_analysis.py

ఈ ఆదేశాన్ని అమలు చేసిన తర్వాత మనకు ఈ క్రింది విధంగా చెప్పబడుతుంది:

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

అప్లికేషన్ అమలులో ఉందని మరియు అభ్యర్థనల కోసం వేచి ఉందని దీని అర్థం localhost:5000/

▍కోడ్ పరిశోధన

అభ్యర్థనలకు ఎలా స్పందిస్తుందో అర్థం చేసుకోవడానికి పైథాన్ అప్లికేషన్ కోడ్‌ని చూద్దాం:

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. ఒక వస్తువును ప్రారంభించడం Flask.
2. దానికి POST అభ్యర్థనలను నిర్వహించడానికి చిరునామాను పేర్కొనడం.
3. ఒక ఆస్తిని తిరిగి పొందడం sentence అభ్యర్థన శరీరం నుండి.
4. అనామక వస్తువును ప్రారంభించడం TextBlob మరియు విలువను పొందడం polarity అభ్యర్థన యొక్క శరీరంలో స్వీకరించబడిన మొదటి వాక్యం కోసం (మా విషయంలో, ఇది విశ్లేషణ కోసం పంపిన ఏకైక వాక్యం).
5. వాక్యం యొక్క వచనాన్ని మరియు దాని కోసం లెక్కించబడిన సూచికను కలిగి ఉన్న ప్రతిస్పందనను అందిస్తుంది polarity.
6. ఫ్లాస్క్ అప్లికేషన్‌ను ప్రారంభించండి, ఇది అందుబాటులో ఉంటుంది 0.0.0.0:5000 (మీరు ఫారమ్ యొక్క నిర్మాణాన్ని ఉపయోగించి కూడా దీన్ని యాక్సెస్ చేయవచ్చు localhost:5000).

అప్లికేషన్‌ను రూపొందించే మైక్రోసర్వీస్‌లు ఇప్పుడు అమలవుతున్నాయి. అవి ఒకదానితో ఒకటి సంభాషించడానికి ట్యూన్ చేయబడ్డాయి. పని యొక్క ఈ దశలో అప్లికేషన్ రేఖాచిత్రం ఇలా కనిపిస్తుంది.

అప్లికేషన్‌ను రూపొందించే అన్ని మైక్రోసర్వీస్‌లు పని క్రమంలో తీసుకురాబడతాయి

ఇప్పుడు, మీరు కొనసాగించే ముందు, మీ రియాక్ట్ అప్లికేషన్‌ను బ్రౌజర్‌లో తెరిచి, దానితో కొంత వాక్యాన్ని అన్వయించడానికి ప్రయత్నించండి. ప్రతిదీ సరిగ్గా జరిగితే - బటన్ను నొక్కిన తర్వాత Send మీరు టెక్స్ట్ ఫీల్డ్ క్రింద విశ్లేషణ ఫలితాలను చూస్తారు.

తదుపరి విభాగంలో, డాకర్ కంటైనర్‌లలో మా మైక్రోసర్వీస్‌లను ఎలా అమలు చేయాలనే దాని గురించి మాట్లాడుతాము. Kubernetes క్లస్టర్‌లో అమలు చేయడానికి అప్లికేషన్‌ను సిద్ధం చేయడానికి ఇది అవసరం.

డాకర్ కంటైనర్లు

Kubernetes కంటైనరైజ్డ్ అప్లికేషన్‌ల విస్తరణ, స్కేలింగ్ మరియు నిర్వహణను ఆటోమేట్ చేసే వ్యవస్థ. దీనిని "కంటైనర్ ఆర్కెస్ట్రేటర్" అని కూడా పిలుస్తారు. కుబెర్నెటెస్ కంటైనర్‌లతో పనిచేస్తుంటే, ఈ వ్యవస్థను ఉపయోగించే ముందు మనం మొదట ఈ కంటైనర్‌లను పొందాలి. అయితే మొదట, కంటైనర్లు ఏమిటో మాట్లాడుకుందాం. బహుశా అది ఏమిటి అనే ప్రశ్నకు ఉత్తమ సమాధానం కనుగొనవచ్చు డాక్యుమెంటేషన్ డాకర్‌కి:

కంటైనర్ ఇమేజ్ అనేది తేలికైన, స్వీయ-నియంత్రణ, ఎక్జిక్యూటబుల్ ప్యాకేజీ, ఇది ఒక అప్లికేషన్‌ను కలిగి ఉంటుంది, ఇందులో దీన్ని అమలు చేయడానికి అవసరమైన ప్రతిదీ ఉంటుంది: అప్లికేషన్ కోడ్, ఎగ్జిక్యూషన్ ఎన్విరాన్‌మెంట్, సిస్టమ్ టూల్స్ మరియు లైబ్రరీలు, సెట్టింగ్‌లు. కంటెయినరైజ్డ్ ప్రోగ్రామ్‌లను Linux మరియు Windows పరిసరాలలో ఉపయోగించవచ్చు మరియు అవస్థాపనతో సంబంధం లేకుండా అవి ఎల్లప్పుడూ ఒకే విధంగా పని చేస్తాయి.

ఉత్పత్తి సర్వర్‌లతో సహా ఏదైనా కంప్యూటర్‌లో కంటైనర్‌లను అమలు చేయవచ్చు మరియు వాటిలో ఉన్న అప్లికేషన్‌లు ఏ వాతావరణంలోనైనా ఒకే విధంగా పనిచేస్తాయని దీని అర్థం.

కంటైనర్‌ల లక్షణాలను అన్వేషించడానికి మరియు అప్లికేషన్‌లను అమలు చేయడానికి ఇతర మార్గాలతో వాటిని సరిపోల్చడానికి, వర్చువల్ మెషీన్ మరియు కంటైనర్‌ని ఉపయోగించి రియాక్ట్ అప్లికేషన్‌ను అందించే ఉదాహరణను చూద్దాం.

▍వర్చువల్ మెషీన్‌ని ఉపయోగించి రియాక్ట్ అప్లికేషన్ యొక్క స్టాటిక్ ఫైల్‌లను అందిస్తోంది

వర్చువల్ మిషన్‌లను ఉపయోగించి స్టాటిక్ ఫైల్‌ల సేవను నిర్వహించడానికి ప్రయత్నిస్తున్నప్పుడు, మేము ఈ క్రింది ప్రతికూలతలను ఎదుర్కొంటాము:

1. ప్రతి వర్చువల్ మిషన్ పూర్తి స్థాయి ఆపరేటింగ్ సిస్టమ్ అయినందున వనరుల అసమర్థ వినియోగం.
2. ప్లాట్‌ఫారమ్ డిపెండెన్సీ. స్థానిక కంప్యూటర్‌లో పని చేసేవి ప్రొడక్షన్ సర్వర్‌లో పని చేయకపోవచ్చు.
3. వర్చువల్ మెషీన్-ఆధారిత పరిష్కారం యొక్క స్లో మరియు రిసోర్స్-ఇంటెన్సివ్ స్కేలింగ్.

Nginx వెబ్ సర్వర్ వర్చువల్ మెషీన్‌లో నడుస్తున్న స్టాటిక్ ఫైల్‌లను అందిస్తోంది

ఇలాంటి సమస్యను పరిష్కరించడానికి కంటైనర్‌లను ఉపయోగించినట్లయితే, వర్చువల్ మిషన్‌లతో పోల్చితే, ఈ క్రింది బలాలు గమనించవచ్చు:

1. వనరులను సమర్థవంతంగా ఉపయోగించడం: డాకర్‌ని ఉపయోగించి ఆపరేటింగ్ సిస్టమ్‌తో పని చేయడం.
2. ప్లాట్‌ఫారమ్ స్వతంత్రమైనది. డెవలపర్ తన కంప్యూటర్‌లో రన్ చేయగల కంటైనర్ ఎక్కడైనా పని చేస్తుంది.
3. ఇమేజ్ లేయర్‌లను ఉపయోగించడం ద్వారా తేలికైన విస్తరణ.

Nginx వెబ్ సర్వర్ కంటైనర్‌లో నడుస్తున్న స్టాటిక్ ఫైల్‌లను అందిస్తోంది

మేము వర్చువల్ మెషీన్‌లు మరియు కంటైనర్‌లను కొన్ని పాయింట్‌లపై మాత్రమే పోల్చాము, అయితే కంటైనర్‌ల బలాన్ని అనుభూతి చెందడానికి ఇది కూడా సరిపోతుంది. ఇది మీరు డాకర్ కంటైనర్ల గురించి వివరాలను కనుగొనవచ్చు.

▍రియాక్ట్ అప్లికేషన్ కోసం కంటైనర్ ఇమేజ్‌ను రూపొందించడం

డాకర్ కంటైనర్ యొక్క ప్రాథమిక బిల్డింగ్ బ్లాక్ ఫైల్ Dockerfile. ఈ ఫైల్ ప్రారంభంలో, కంటైనర్ యొక్క బేస్ ఇమేజ్‌తో రికార్డ్ చేయబడింది, ఆపై నిర్దిష్ట అప్లికేషన్ యొక్క అవసరాలను తీర్చగల కంటైనర్‌ను ఎలా సృష్టించాలో సూచించే సూచనల క్రమం ఉంది.

మేము ఫైల్‌తో పని చేయడానికి ముందు Dockerfile, Nginx సర్వర్‌కు అప్‌లోడ్ చేయడానికి రియాక్ట్ అప్లికేషన్ ఫైల్‌లను సిద్ధం చేయడానికి మనం ఏమి చేశామో గుర్తుచేసుకుందాం:

1. రియాక్ట్ అప్లికేషన్ ప్యాకేజీని రూపొందించడం (npm run build).
2. Nginx సర్వర్‌ను ప్రారంభిస్తోంది.
3. డైరెక్టరీ కంటెంట్‌లను కాపీ చేస్తోంది build ప్రాజెక్ట్ ఫోల్డర్ నుండి sa-frontend సర్వర్ ఫోల్డర్‌కు nginx/html.

దిగువన మీరు కంటైనర్‌ను సృష్టించడం మరియు మీ స్థానిక కంప్యూటర్‌లో ప్రదర్శించబడే పై ​​దశల మధ్య సమాంతరాలను చూడవచ్చు.

▍SA-Frontend అప్లికేషన్ కోసం డాకర్‌ఫైల్‌ను సిద్ధం చేస్తోంది

ఇందులో ఉండే సూచనలు Dockerfile అప్లికేషన్ కోసం SA-Frontend, కేవలం రెండు జట్లు మాత్రమే ఉంటాయి. వాస్తవం ఏమిటంటే, Nginx అభివృద్ధి బృందం ప్రాథమికంగా సిద్ధం చేసింది ఒక చిత్రం Nginx కోసం, మేము మా చిత్రాన్ని రూపొందించడానికి ఉపయోగిస్తాము. మనం వివరించాల్సిన రెండు దశలు ఇవి:

1. చిత్రం యొక్క ఆధారం Nginx చిత్రం అయి ఉండాలి.
2. ఫోల్డర్ కంటెంట్‌లు sa-frontend/build ఇమేజ్ ఫోల్డర్‌కి కాపీ చేయాలి nginx/html.

మీరు ఈ వివరణ నుండి ఫైల్‌కి వెళితే Dockerfile, అప్పుడు ఇది ఇలా కనిపిస్తుంది:

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

మీరు చూడగలిగినట్లుగా, ఇక్కడ ప్రతిదీ చాలా సులభం, మరియు ఫైల్ యొక్క కంటెంట్‌లు చాలా చదవగలిగేవి మరియు అర్థమయ్యేలా ఉంటాయి. ఈ ఫైల్ చిత్రాన్ని తీయమని సిస్టమ్‌కు చెబుతుంది nginx దానిలో ఇప్పటికే ఉన్న ప్రతిదానితో మరియు డైరెక్టరీలోని కంటెంట్‌లను కాపీ చేయండి build డైరెక్టరీకి nginx/html.

ఇక్కడ మీరు ఫోల్డర్ నుండి ఫైల్‌లను ఎక్కడ కాపీ చేయాలో నాకు ఎలా తెలుసు అనే ప్రశ్న ఉండవచ్చు build, అంటే, మార్గం ఎక్కడ నుండి వచ్చింది /usr/share/nginx/html. నిజానికి, ఇక్కడ కూడా సంక్లిష్టంగా ఏమీ లేదు. వాస్తవం ఏమిటంటే సంబంధిత సమాచారాన్ని కనుగొనవచ్చు వివరణ చిత్రం.

▍చిత్రాన్ని నిర్మించడం మరియు దానిని రిపోజిటరీకి అప్‌లోడ్ చేయడం

మేము పూర్తి చేసిన చిత్రంతో పని చేయడానికి ముందు, మనం దానిని ఇమేజ్ రిపోజిటరీకి నెట్టాలి. దీన్ని చేయడానికి, మేము ఉచిత క్లౌడ్ ఇమేజ్ హోస్టింగ్ ప్లాట్‌ఫారమ్ డాకర్ హబ్‌ని ఉపయోగిస్తాము. పని యొక్క ఈ దశలో మీరు ఈ క్రింది వాటిని చేయాలి:

1. ఏర్పాటు డాకర్.
2. డాకర్ హబ్ వెబ్‌సైట్‌లో నమోదు చేసుకోండి.
3. టెర్మినల్‌లో కింది ఆదేశాన్ని అమలు చేయడం ద్వారా మీ ఖాతాకు లాగిన్ అవ్వండి:

   docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"

ఇప్పుడు మీరు డైరెక్టరీకి వెళ్లడానికి టెర్మినల్‌ను ఉపయోగించాలి sa-frontend మరియు అక్కడ కింది ఆదేశాన్ని అమలు చేయండి:

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

ఇలాంటి ఆదేశాలలో ఇక్కడ మరియు మరింత $DOCKER_USER_ID మీ డాకర్ హబ్ వినియోగదారు పేరుతో భర్తీ చేయాలి. ఉదాహరణకు, కమాండ్ యొక్క ఈ భాగం ఇలా ఉండవచ్చు: rinormaloku/sentiment-analysis-frontend.

ఈ సందర్భంలో, ఈ ఆదేశాన్ని దాని నుండి తీసివేయడం ద్వారా తగ్గించవచ్చు -f Dockerfile, ఈ ఫైల్ ఇప్పటికే మనం ఈ ఆదేశాన్ని అమలు చేస్తున్న ఫోల్డర్‌లో ఉన్నందున.

పూర్తయిన చిత్రాన్ని రిపోజిటరీకి పంపడానికి, మనకు కింది ఆదేశం అవసరం:

docker push $DOCKER_USER_ID/sentiment-analysis-frontend

దీన్ని పూర్తి చేసిన తర్వాత, క్లౌడ్ స్టోరేజ్‌కి ఇమేజ్‌ని అప్‌లోడ్ చేయడం విజయవంతమైందో లేదో అర్థం చేసుకోవడానికి డాకర్ హబ్‌లోని మీ రిపోజిటరీల జాబితాను తనిఖీ చేయండి.

▍కంటైనర్‌ను నడుపుతోంది

ఇప్పుడు ఎవరైనా చిత్రాన్ని డౌన్‌లోడ్ చేసి రన్ చేయవచ్చు, దీనిని అంటారు $DOCKER_USER_ID/sentiment-analysis-frontend. దీన్ని చేయడానికి, మీరు కింది ఆదేశాల క్రమాన్ని అమలు చేయాలి:

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

ఇప్పుడు కంటైనర్ రన్ అవుతోంది, మనకు అవసరమైన ఇతర చిత్రాలను సృష్టించడం ద్వారా మనం పనిని కొనసాగించవచ్చు. కానీ కొనసాగే ముందు, డిజైన్‌ను అర్థం చేసుకుందాం 80:80, ఇది ఇమేజ్ లాంచ్ కమాండ్‌లో కనిపిస్తుంది మరియు గందరగోళంగా అనిపించవచ్చు.

• మొదటి సంఖ్య 80 — ఇది హోస్ట్ పోర్ట్ నంబర్ (అంటే స్థానిక కంప్యూటర్).
• రెండవ సంఖ్య 80 అభ్యర్థనను ఫార్వార్డ్ చేయవలసిన కంటైనర్ యొక్క పోర్ట్.

కింది దృష్టాంతాన్ని పరిగణించండి.

పోర్ట్ ఫార్వార్డింగ్

సిస్టమ్ పోర్ట్ నుండి అభ్యర్థనలను దారి మళ్లిస్తుంది <hostPort> పోర్టుకు <containerPort>. అంటే, పోర్ట్ యాక్సెస్ 80 కంప్యూటర్ పోర్టుకు మళ్లించబడుతుంది 80 కంటైనర్.

పోర్ట్ నుండి 80 స్థానిక కంప్యూటర్‌లో తెరవబడింది, ఆపై మీరు ఈ కంప్యూటర్ నుండి అప్లికేషన్‌ను యాక్సెస్ చేయవచ్చు localhost:80. మీ సిస్టమ్ డాకర్‌కు మద్దతు ఇవ్వకపోతే, అప్లికేషన్ డాకర్ వర్చువల్ మెషీన్‌లో అమలు చేయబడుతుంది, దాని చిరునామా ఇలా ఉంటుంది <docker-machine ip>:80. డాకర్ వర్చువల్ మెషీన్ యొక్క IP చిరునామాను తెలుసుకోవడానికి, మీరు ఆదేశాన్ని ఉపయోగించవచ్చు docker-machine ip.

ఈ సమయంలో, ఫ్రంట్-ఎండ్ అప్లికేషన్ కంటైనర్‌ను విజయవంతంగా ప్రారంభించిన తర్వాత, మీరు బ్రౌజర్‌లో దాని పేజీని తెరవగలరు.

▍The .dockerignore ఫైల్

అప్లికేషన్ చిత్రాన్ని సేకరిస్తోంది SA-Frontend, ఈ ప్రక్రియ చాలా నెమ్మదిగా జరుగుతుందని మేము గమనించవచ్చు. చిత్రం నిర్మాణ సందర్భం తప్పనిసరిగా డాకర్ డెమోన్‌కు పంపబడాలి కాబట్టి ఇది జరుగుతుంది. బిల్డ్ సందర్భాన్ని సూచించే డైరెక్టరీ కమాండ్ యొక్క చివరి ఆర్గ్యుమెంట్‌గా పేర్కొనబడింది docker build. మా సందర్భంలో, ఈ కమాండ్ చివరిలో ఒక చుక్క ఉంది. ఇది నిర్మాణ సందర్భంలో కింది నిర్మాణాన్ని చేర్చడానికి కారణమవుతుంది:

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

కానీ ఇక్కడ ఉన్న అన్ని ఫోల్డర్‌లలో, మనకు ఫోల్డర్ మాత్రమే అవసరం build. మరేదైనా లోడ్ చేయడం వల్ల సమయం వృధా అవుతుంది. ఏ డైరెక్టరీలను విస్మరించాలో డాకర్‌కి చెప్పడం ద్వారా మీరు నిర్మాణాన్ని వేగవంతం చేయవచ్చు. దీన్ని చేయడానికి, మనకు ఫైల్ అవసరం .dockerignore. మీరు, మీకు ఫైల్ గురించి తెలిసి ఉంటే .gitignore, ఈ ఫైల్ యొక్క నిర్మాణం బహుశా సుపరిచితమైనదిగా అనిపించవచ్చు. ఇమేజ్ బిల్డ్ సిస్టమ్ విస్మరించగల డైరెక్టరీలను ఇది జాబితా చేస్తుంది. మా విషయంలో, ఈ ఫైల్ యొక్క కంటెంట్‌లు ఇలా కనిపిస్తాయి:

node_modules
src
public

ఫైలు .dockerignore ఫైల్ ఉన్న అదే ఫోల్డర్‌లో ఉండాలి Dockerfile. ఇప్పుడు చిత్రాన్ని నిర్మించడానికి కొన్ని సెకన్ల సమయం పడుతుంది.

ఇప్పుడు జావా అప్లికేషన్ కోసం ఇమేజ్‌పై పని చేద్దాం.

▍జావా అప్లికేషన్ కోసం కంటైనర్ ఇమేజ్‌ను రూపొందించడం

మీకు తెలుసా, కంటైనర్ చిత్రాలను రూపొందించడానికి మీరు తెలుసుకోవలసిన ప్రతిదాన్ని మీరు ఇప్పటికే నేర్చుకున్నారు. అందుకే ఈ విభాగం చాలా తక్కువగా ఉంటుంది.

ఫైల్‌ను తెరవండి Dockerfileప్రాజెక్ట్ ఫోల్డర్‌లో ఉన్నది sa-webapp. మీరు ఈ ఫైల్ యొక్క టెక్స్ట్‌ను చదివితే, మీరు ఇందులో కీలక పదాలతో ప్రారంభించి రెండు కొత్త నిర్మాణాలను మాత్రమే చూస్తారు ENV и EXPOSE:

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

కీవర్డ్ ENV డాకర్ కంటైనర్‌లలో ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ని డిక్లేర్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ప్రత్యేకించి, మా విషయంలో, ఇది టెక్స్ట్ విశ్లేషణ చేసే అప్లికేషన్ యొక్క APIని యాక్సెస్ చేయడానికి URLని పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది.

కీవర్డ్ EXPOSE పోర్ట్‌ను తెరవమని డాకర్‌కి చెప్పడానికి మిమ్మల్ని అనుమతిస్తుంది. అప్లికేషన్‌ను రన్ చేస్తున్నప్పుడు మేము ఈ పోర్ట్‌ని ఉపయోగించబోతున్నాము. ఇక్కడ మీరు దానిని గమనించవచ్చు Dockerfile అప్లికేషన్ కోసం SA-Frontend అటువంటి ఆదేశం లేదు. ఇది డాక్యుమెంటేషన్ ప్రయోజనాల కోసం మాత్రమే, మరో మాటలో చెప్పాలంటే, ఈ నిర్మాణం చదివే వారి కోసం ఉద్దేశించబడింది Dockerfile.

చిత్రాన్ని నిర్మించడం మరియు దానిని రిపోజిటరీకి నెట్టడం మునుపటి ఉదాహరణలో వలె కనిపిస్తుంది. మీరు మీ సామర్ధ్యాలలో ఇంకా చాలా నమ్మకంగా లేకుంటే, సంబంధిత ఆదేశాలను ఫైల్లో కనుగొనవచ్చు README.md ఫోల్డర్‌లో sa-webapp.

▍పైథాన్ అప్లికేషన్ కోసం కంటైనర్ ఇమేజ్‌ను రూపొందించడం

మీరు ఫైల్ యొక్క కంటెంట్లను పరిశీలిస్తే 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. అదనంగా, పర్యావరణ వేరియబుల్‌ని మళ్లీ కేటాయించడం ద్వారా జావా అప్లికేషన్ నుండి అభ్యర్థనల కోసం పైథాన్ అప్లికేషన్ వినే పోర్ట్‌ను మనం కాన్ఫిగర్ చేయాలి. 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 చిరునామాను ఎలా కనుగొనాలో తెలుసుకోవడానికి, ఫైల్‌ని చూడండి README.

అప్లికేషన్ కంటైనర్‌ను ప్రారంభిద్దాం sa-frontend:

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

ఇప్పుడు బ్రౌజర్‌లోని చిరునామాకు వెళ్లడానికి ప్రతిదీ సిద్ధంగా ఉంది localhost:80 మరియు అప్లికేషన్ ప్రయత్నించండి.

మీరు పోర్ట్‌ని మార్చినట్లయితే దయచేసి గమనించండి sa-webapp, లేదా మీరు డాకర్ వర్చువల్ మెషీన్‌ను నడుపుతున్నట్లయితే, మీరు ఫైల్‌ను సవరించాలి App.js ఫోల్డర్ నుండి sa-frontendపద్ధతిలో IP చిరునామా లేదా పోర్ట్ సంఖ్యను మార్చడం ద్వారా analyzeSentence(), పాత డేటాకు బదులుగా ప్రస్తుత సమాచారాన్ని భర్తీ చేయడం. దీని తరువాత, మీరు చిత్రాన్ని తిరిగి కలపాలి మరియు దానిని ఉపయోగించాలి.

మా అప్లికేషన్ రేఖాచిత్రం ఇప్పుడు ఇలా ఉంది.

మైక్రోసర్వీస్ కంటైనర్లలో నడుస్తుంది

సారాంశం: మనకు కుబెర్నెట్స్ క్లస్టర్ ఎందుకు అవసరం?

ఇప్పుడే ఫైళ్లను పరిశీలించాం Dockerfile, చిత్రాలను ఎలా నిర్మించాలి మరియు వాటిని డాకర్ రిపోజిటరీకి ఎలా నెట్టాలి అనే దాని గురించి మాట్లాడారు. అదనంగా, ఫైల్‌ని ఉపయోగించి ఇమేజ్ అసెంబ్లీని ఎలా వేగవంతం చేయాలో మేము నేర్చుకున్నాము .dockerignore. ఫలితంగా, మా మైక్రోసర్వీసులు ఇప్పుడు డాకర్ కంటైనర్‌లలో నడుస్తాయి. ఇక్కడ మీరు మాకు కుబెర్నెట్స్ ఎందుకు అవసరం అనే దాని గురించి పూర్తిగా సమర్థించబడిన ప్రశ్న ఉండవచ్చు. ఈ విషయం యొక్క రెండవ భాగం ఈ ప్రశ్నకు సమాధానం ఇవ్వడానికి అంకితం చేయబడుతుంది. ఈ సమయంలో, ఈ క్రింది ప్రశ్నను పరిగణించండి:
టెక్స్ట్ విశ్లేషణ కోసం మా వెబ్ అప్లికేషన్ ప్రపంచవ్యాప్తంగా ప్రజాదరణ పొందిందని అనుకుందాం. అతనికి ప్రతి నిమిషానికి లక్షలాది అభ్యర్థనలు వస్తుంటాయి. మైక్రోసర్వీస్ అని దీని అర్థం sa-webapp и sa-logic అపారమైన భారం ఉంటుంది. మైక్రోసర్వీస్‌లు నడుస్తున్న కంటైనర్‌లను స్కేల్ చేయడం ఎలా?

మూలం: www.habr.com