ప్రోహోస్టర్ > బ్లాగ్ > పరిపాలన > కుబెర్నెట్స్ అభివృద్ధి కోసం స్కాఫోల్డ్ యొక్క సమీక్ష

కుబెర్నెట్స్ అభివృద్ధి కోసం స్కాఫోల్డ్ యొక్క సమీక్ష

కుబెర్నెట్స్ అభివృద్ధి కోసం స్కాఫోల్డ్ యొక్క సమీక్ష

ఏడాదిన్నర క్రితం, మార్చి 5, 2018న, Google CI/CD కోసం దాని ఓపెన్ సోర్స్ ప్రాజెక్ట్ యొక్క మొదటి ఆల్ఫా వెర్షన్‌ను విడుదల చేసింది స్కాఫోల్డ్, దీని లక్ష్యం "సరళమైన మరియు పునరావృతమయ్యే కుబెర్నెట్స్ అభివృద్ధి"ని సృష్టించడం, తద్వారా డెవలపర్‌లు పరిపాలన కంటే అభివృద్ధిపై దృష్టి పెట్టవచ్చు. స్కాఫోల్డ్ గురించి ఏమి ఆసక్తికరంగా ఉండవచ్చు? ఇది ముగిసినట్లుగా, ఇది డెవలపర్‌కు మరియు బహుశా ఆపరేషన్స్ ఇంజనీర్‌కు కూడా శక్తివంతమైన సాధనంగా చేయగల దాని స్లీవ్‌లో కొన్ని ఉపాయాలు ఉన్నాయి. ప్రాజెక్ట్ మరియు దాని సామర్థ్యాలతో పరిచయం చేసుకుందాం.

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

సిద్ధాంతం. ప్రయోజనం మరియు సామర్థ్యాలు

కాబట్టి, సాధారణంగా చెప్పాలంటే, స్కాఫోల్డ్ CI/CD సైకిల్‌ను ఆటోమేట్ చేసే సమస్యను పరిష్కరిస్తుంది (బిల్డ్, పుష్, డిప్లాయ్ దశల్లో), డెవలపర్ ప్రాంప్ట్ ఫీడ్‌బ్యాక్ అందించడం, అనగా. తదుపరి కోడ్ మార్పుల ఫలితాన్ని త్వరగా స్వీకరించగల సామర్థ్యం - కుబెర్నెటెస్ క్లస్టర్‌లో నడుస్తున్న అప్‌డేట్ చేసిన అప్లికేషన్ రూపంలో. మరియు ఇది వేర్వేరు సర్క్యూట్‌లలో (దేవ్, స్టేజ్, ప్రొడక్షన్...) పని చేయగలదు, దీని కోసం రోల్‌అవుట్ కోసం సంబంధిత పైప్‌లైన్‌లను వివరించడానికి స్కాఫోల్డ్ సహాయపడుతుంది.

స్కాఫోల్డ్ యొక్క సోర్స్ కోడ్ గోలో వ్రాయబడింది, ద్వారా పంపిణీ చేయబడింది ఉచిత Apache లైసెన్స్ 2.0 (GitHub) కింద.

ప్రధాన విధులు మరియు లక్షణాలను చూద్దాం. మొదటి వాటిలో ఈ క్రిందివి ఉన్నాయి:

  • CI/CD పైప్‌లైన్‌లను రూపొందించడానికి స్కాఫోల్డ్ సాధనాలను అందిస్తుంది.
  • నేపథ్యంలో సోర్స్ కోడ్‌లో మార్పులను పర్యవేక్షించడానికి మరియు కంటైనర్ చిత్రాలలో కోడ్‌ను అసెంబ్లింగ్ చేసే స్వయంచాలక ప్రక్రియను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, ఈ చిత్రాలను డాకర్ రిజిస్ట్రీలో ప్రచురించడం మరియు వాటిని కుబెర్నెటెస్ క్లస్టర్‌కు అమలు చేయడం.
  • కంటైనర్‌లోని వర్కింగ్ డైరెక్టరీతో రిపోజిటరీలోని ఫైల్‌లను సమకాలీకరిస్తుంది.
  • కంటైనర్-స్ట్రక్చర్-టెస్ట్ ఉపయోగించి ఆటోమేటిక్‌గా పరీక్షిస్తుంది.
  • ఫార్వర్డ్ పోర్ట్‌లు.
  • కంటైనర్‌లో అమలవుతున్న అప్లికేషన్ లాగ్‌లను చదువుతుంది.
  • Java, Node.js, Python, Goలో వ్రాసిన అప్లికేషన్‌లను డీబగ్గింగ్ చేయడంలో సహాయపడుతుంది.

ఇప్పుడు లక్షణాల గురించి:

  • స్కాఫోల్డ్‌లో క్లస్టర్-సైడ్ భాగాలు లేవు. అంటే, ఈ యుటిలిటీని ఉపయోగించడానికి కుబెర్నెట్‌లను మరింత కాన్ఫిగర్ చేయవలసిన అవసరం లేదు.
  • మీ అప్లికేషన్ కోసం వివిధ పైప్‌లైన్‌లు. మీరు డెవలప్ చేస్తున్నప్పుడు స్థానిక మినీక్యూబ్‌కి, ఆపై స్టేజ్ లేదా ప్రొడక్షన్‌కి కోడ్‌ని అందించాలా? ఈ ప్రయోజనం కోసం ఉన్నాయి ప్రొఫైల్స్ మరియు వినియోగదారు కాన్ఫిగరేషన్‌లు, ఎన్విరాన్‌మెంట్ వేరియబుల్స్ మరియు ఫ్లాగ్‌లు, ఇవి ఒక అప్లికేషన్ కోసం వివిధ పైప్‌లైన్‌లను వివరించడానికి మిమ్మల్ని అనుమతిస్తాయి.
  • CLI. YAMLలో కన్సోల్ యుటిలిటీ మరియు కాన్ఫిగరేషన్‌లు మాత్రమే. ఇంటర్నెట్‌లో మీరు సృష్టించే ప్రయత్నాలకు సూచనలను కనుగొనవచ్చు ప్రయోగాత్మక GUI, అయితే, ప్రస్తుతానికి దీని అర్థం ఎవరికైనా అతని అవసరం అని అర్థం, కానీ నిజంగా కాదు.
  • మాడ్యులారిటీ. స్కాఫోల్డ్ అనేది స్వతంత్ర హార్వెస్టర్ కాదు, కానీ నిర్దిష్ట పనుల కోసం వ్యక్తిగత మాడ్యూల్‌లు లేదా ఇప్పటికే ఉన్న పరిష్కారాలను ఉపయోగించడానికి ప్రయత్నిస్తుంది.

తరువాతి ఉదాహరణ:

  • అసెంబ్లీ దశలో మీరు వీటిని ఉపయోగించవచ్చు:
    • డాకర్ బిల్డ్ స్థానికంగా, కనికోను ఉపయోగించి క్లస్టర్‌లో లేదా Google క్లౌడ్ బిల్డ్‌లో;
    • స్థానికంగా బజెల్;
    • జిబ్ మావెన్ మరియు జిబ్ గ్రాడిల్ స్థానికంగా లేదా Google క్లౌడ్ బిల్డ్‌లో;
    • కస్టమ్ బిల్డ్ స్క్రిప్ట్‌లు స్థానికంగా అమలవుతాయి. మీరు మరొక (మరింత అనువైన/తెలిసిన/...) బిల్డ్ సొల్యూషన్‌ని అమలు చేయవలసి వస్తే, అది స్క్రిప్ట్‌లో వివరించబడింది, తద్వారా స్కాఫోల్డ్ దానిని లాంచ్ చేస్తుంది (డాక్యుమెంటేషన్ నుండి ఉదాహరణ) ఇది స్క్రిప్ట్‌ని ఉపయోగించి పిలవబడే ఏదైనా కలెక్టర్‌ని ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తుంది;
  • పరీక్ష దశలో, ఇప్పటికే పేర్కొన్నది కంటైనర్-నిర్మాణం-పరీక్ష;
  • విస్తరణ కోసం ఈ క్రిందివి అందించబడ్డాయి:
    • కుబెక్ట్ల్;
    • హెల్మ్;
    • అనుకూలీకరించండి.

దీనికి ధన్యవాదాలు, స్కాఫోల్డ్‌ను ప్రత్యేకమైనదిగా పిలుస్తారు CI/CDని నిర్మించడానికి ఫ్రేమ్‌వర్క్. దీన్ని ఉపయోగిస్తున్నప్పుడు ఇక్కడ ఒక ఉదాహరణ వర్క్‌ఫ్లో ఉంది (ప్రాజెక్ట్ డాక్యుమెంటేషన్ నుండి):

కుబెర్నెట్స్ అభివృద్ధి కోసం స్కాఫోల్డ్ యొక్క సమీక్ష

సాధారణ పరంగా స్కాఫోల్డ్ యొక్క పని ఎలా ఉంటుంది?

  1. యుటిలిటీ సోర్స్ కోడ్ డైరెక్టరీలో మార్పులను పర్యవేక్షిస్తుంది. ఫైల్‌లకు మార్పులు చేసినట్లయితే, అవి కుబెర్నెట్స్ క్లస్టర్‌లోని అప్లికేషన్ పాడ్‌తో సమకాలీకరించబడతాయి. వీలైతే, చిత్రాన్ని తిరిగి కలపకుండా. లేకపోతే, ఒక కొత్త చిత్రం అసెంబుల్ చేయబడుతుంది.
  2. సమీకరించబడిన చిత్రం కంటైనర్-స్ట్రక్చర్-టెస్ట్ ఉపయోగించి తనిఖీ చేయబడుతుంది, ట్యాగ్ చేయబడింది మరియు డాకర్ రిజిస్ట్రీకి పంపబడుతుంది.
  3. దీని తరువాత, చిత్రం అమలు చేయబడుతుంది - కుబెర్నెటెస్ క్లస్టర్‌లో అమలు చేయబడుతుంది.
  4. కమాండ్ ఉపయోగించి లాంచ్ ప్రారంభించబడితే skaffold dev, ఆపై మేము అప్లికేషన్ నుండి లాగ్‌లను స్వీకరించడం ప్రారంభిస్తాము మరియు అన్ని చర్యలను మళ్లీ పునరావృతం చేయడానికి స్కాఫోల్డ్ మార్పుల కోసం వేచి ఉంటుంది.

కుబెర్నెట్స్ అభివృద్ధి కోసం స్కాఫోల్డ్ యొక్క సమీక్ష
స్కాఫోల్డ్ ఆపరేషన్ యొక్క ప్రధాన దశల ఉదాహరణ

సాధన. స్కాఫోల్డ్ ప్రయత్నిస్తున్నారు

స్కాఫోల్డ్ ఉపయోగాన్ని ప్రదర్శించడానికి, నేను ఒక ఉదాహరణ తీసుకుంటాను GitHub ప్రాజెక్ట్ రిపోజిటరీ. మార్గం ద్వారా, అక్కడ వివిధ ప్రత్యేకతలను పరిగణనలోకి తీసుకునే అనేక ఇతర ఉదాహరణలను మీరు కనుగొనవచ్చు. నేను మినీక్యూబ్‌లో అన్ని చర్యలను స్థానికంగా నిర్వహిస్తాను. ఇన్‌స్టాలేషన్ సులభం మరియు కొన్ని నిమిషాలు పడుతుంది మరియు ప్రారంభించడానికి మీకు kubectl అవసరం.

స్కాఫోల్డ్‌ని ఇన్‌స్టాల్ చేయండి:

curl -Lo skaffold https://storage.googleapis.com/skaffold/releases/latest/skaffold-linux-amd64
chmod +x skaffold
sudo mv skaffold /usr/local/bin
skaffold version
v0.37.1

అవసరమైన ఉదాహరణలతో స్కాఫోల్డ్ రిపోజిటరీని క్లోన్ చేద్దాం:

git clone https://github.com/GoogleContainerTools/skaffold
cd skaffold/examples/microservices

నేను రెండు పాడ్‌లతో ఒక ఉదాహరణను ఎంచుకున్నాను, ఒక్కొక్కటి ఒక చిన్న గో అప్లికేషన్‌ను కలిగి ఉంది. ఒక అప్లికేషన్ ఫ్రంటెండ్ (leeroy-web), ఇది అభ్యర్థనను రెండవ అప్లికేషన్‌కి దారి మళ్లిస్తుంది - బ్యాకెండ్ (leeroy-app). ఇది ఎలా ఉంటుందో చూద్దాం:

~/skaffold/examples/microservices # tree
.
├── leeroy-app
│   ├── app.go
│   ├── Dockerfile
│   └── kubernetes
│       └── deployment.yaml
├── leeroy-web
│   ├── Dockerfile
│   ├── kubernetes
│   │   └── deployment.yaml
│   └── web.go
├── README.adoc
└── skaffold.yaml
 
4 directories, 8 files

leeroy-app మరియు leeroy-web ఈ కోడ్‌ని స్థానికంగా రూపొందించడానికి Go కోడ్ మరియు సాధారణ డాకర్‌ఫైల్‌లను కలిగి ఉన్నాయి:

~/skaffold/examples/microservices # cat leeroy-app/Dockerfile
FROM golang:1.12.9-alpine3.10 as builder
COPY app.go .
RUN go build -o /app .
 
FROM alpine:3.10
CMD ["./app"]
COPY --from=builder /app .

నేను అప్లికేషన్ కోడ్ ఇవ్వను - అది తెలుసుకుంటే సరిపోతుంది leeroy-web అభ్యర్థనలను అంగీకరిస్తుంది మరియు వాటిని ప్రాక్సీ చేస్తుంది leeroy-app. అందువల్ల ఫైళ్లలో Deployment.yaml కోసం మాత్రమే సేవ ఉంది app (అంతర్గత రూటింగ్ కోసం). పాడ్ పోర్ట్ web అప్లికేషన్‌కు శీఘ్ర ప్రాప్యత కోసం మేము దానిని మాకు ఫార్వార్డ్ చేస్తాము.

ఇది కనిపిస్తుంది skaffold.yaml:

~/skaffold/examples/microservices # cat skaffold.yaml
apiVersion: skaffold/v1beta13
kind: Config
build:
  artifacts:
    - image: leeroy-web
      context: ./leeroy-web/
    - image: leeroy-app
      context: ./leeroy-app/
deploy:
  kubectl:
    manifests:
      - ./leeroy-web/kubernetes/*
      - ./leeroy-app/kubernetes/*
portForward:
  - resourceType: deployment
    resourceName: leeroy-web
    port: 8080
    localPort: 9000

పైన పేర్కొన్న అన్ని దశలు ఇక్కడ వివరించబడ్డాయి. ఈ కాన్ఫిగరేషన్‌తో పాటు, గ్లోబల్ సెట్టింగ్‌లతో కూడిన ఫైల్ కూడా ఉంది - ~/.skaffold/config. ఇది మానవీయంగా లేదా CLI ద్వారా సవరించబడుతుంది - ఉదాహరణకు, ఇలా:

skaffold config set --global local-cluster true

ఈ ఆదేశం గ్లోబల్ వేరియబుల్‌ను సెట్ చేస్తుంది local-cluster అర్థం లోకి true, దీని తర్వాత స్కాఫోల్డ్ చిత్రాలను రిమోట్ రిజిస్ట్రీకి నెట్టడానికి ప్రయత్నించదు. మీరు స్థానికంగా అభివృద్ధి చేస్తుంటే, స్థానికంగా చిత్రాలను రూపొందించడానికి మీరు ఈ ఆదేశాన్ని ఉపయోగించవచ్చు.

తిరిగి skaffold.yaml:

  • వేదిక మీద build మీరు చిత్రాన్ని స్థానికంగా సేకరించి, సేవ్ చేయాలని మేము పేర్కొంటున్నాము. బిల్డ్ మొదటిసారిగా అమలు చేయబడిన తర్వాత, మేము ఈ క్రింది వాటిని చూస్తాము: 
    // т.к. Minikube создает кластер в отдельной виртуальной машине,
// придется проникнуть внутрь, чтобы найти образы
# minikube ssh
$ docker images
REPOSITORY                                TAG                                                                IMAGE ID            CREATED             SIZE 
leeroy-app                                7d55a50803590b2ff62e47e6f240723451f3ef6f8c89aeb83b34e661aa287d2e   7d55a5080359        4 hours ago         13MB 
leeroy-app                                v0.37.1-171-g0270a0c-dirty                                         7d55a5080359        4 hours ago         13MB
leeroy-web                                5063bfb29d984db1ff70661f17d6efcc5537f2bbe6aa6907004ad1ab38879681   5063bfb29d98        5 hours ago         13.1MB
leeroy-web                                v0.37.1-171-g0270a0c-dirty                                         5063bfb29d98        5 hours ago         13.1MB

    మీరు చూడగలిగినట్లుగా, స్కాఫోల్డ్ చిత్రాలను స్వయంగా ట్యాగ్ చేసారు. మార్గం ద్వారా, అనేక ట్యాగింగ్ విధానాలకు మద్దతు ఉంది.

  • కాన్ఫిగరేషన్‌లో ఇది సూచించబడుతుంది context: ./leeroy-app/, అనగా చిత్రం సేకరించిన సందర్భం పేర్కొనబడింది.
  • విస్తరణ దశలో, అవసరమైన మానిఫెస్ట్‌ల కోసం మేము kubectl మరియు మాస్క్‌ని ఉపయోగిస్తామని నిర్ణయించబడింది.
  • PortForward: మనం సాధారణంగా పోర్ట్‌లను ఎలా ఫార్వార్డ్ చేసామో అదే విధంగా kubectl port-forward, మేము ఈ ఆదేశాన్ని కాల్ చేయడానికి స్కాఫోల్డ్‌కు సూచనలను అందిస్తాము. ఈ సందర్భంలో, స్థానిక పోర్ట్ 9000 పేరుతో డిప్లాయ్‌మెంట్‌లో 8080కి ఫార్వార్డ్ చేయబడింది leeroy-web.

ఇది ప్రారంభించాల్సిన సమయం skaffold dev: బృందం కొనసాగుతున్న “ఫీడ్‌బ్యాక్ లూప్”ని సృష్టిస్తుంది, అనగా. ఇది అన్నింటినీ సేకరించి, దానిని క్లస్టర్‌లో అమర్చడమే కాకుండా, ప్రస్తుతం పాడ్‌ల స్థితి గురించి మీకు తెలియజేస్తుంది, మార్పులను పర్యవేక్షిస్తుంది మరియు పాడ్‌ల స్థితిని అప్‌డేట్ చేస్తుంది.

ప్రయోగ ఫలితం ఇక్కడ ఉంది skaffold dev --port-forward తిరిగి సమీకరించేటప్పుడు:

కుబెర్నెట్స్ అభివృద్ధి కోసం స్కాఫోల్డ్ యొక్క సమీక్ష

ముందుగా, కాష్ ఉపయోగించబడుతుందని మీరు చూడవచ్చు. తరువాత, అప్లికేషన్ సమీకరించబడింది, అమలు చేయబడుతుంది మరియు పోర్ట్‌లు ఫార్వార్డ్ చేయబడతాయి. పేర్కొన్నప్పటి నుండి --port-forward, స్కాఫోల్డ్ పోర్ట్‌ని ఫార్వార్డ్ చేసింది web, అతను అడిగారు, కానీ ఇక్కడ app అతను తన స్వంత అభీష్టానుసారం విసిరాడు (సమీప ఉచితమైనదాన్ని ఎంచుకున్నాడు). దీని తరువాత, మేము అప్లికేషన్ల నుండి మొదటి లాగ్లను అందుకుంటాము.

ఇది పనిచేస్తుందో లేదో తనిఖీ చేద్దాం?

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-6998dfcc95-2nxvf   1/1     Running   0          103s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          103s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy app!!!

ఫైల్‌ను సవరిస్తోంది leeroy-app/app.go - కొన్ని సెకన్లు గడిచిపోతాయి... మరియు:

~/skaffold/examples/microservices # kubectl get po
NAME                          READY   STATUS    RESTARTS   AGE
leeroy-app-ffd79d986-l6nwp    1/1     Running   0          11s
leeroy-web-69f7d47c9d-5ff77   1/1     Running   0          4m59s
~/skaffold/examples/microservices # curl localhost:9000
leeroooooy Habr!!!

అదే సమయంలో, స్కాఫోల్డ్ కూడా ఒక పాయింట్ మినహా కన్సోల్‌లో మునుపటిలా అదే విషయాన్ని ప్రదర్శించింది: ఇది మాత్రమే బయటకు వచ్చింది leeroy-app, మరియు ఒకేసారి కాదు.

మరింత సాధన

క్రొత్త ప్రాజెక్ట్‌ను సృష్టించేటప్పుడు, స్కాఫోల్డ్ కోసం కాన్ఫిగరేషన్‌లను ఆదేశాన్ని ఉపయోగించి బూట్‌స్ట్రాప్ చేయవచ్చని కూడా పేర్కొనడం విలువ. init, ఇది చాలా సౌకర్యవంతంగా ఉంటుంది. అదనంగా, మీరు అనేక కాన్ఫిగర్‌లను వ్రాయవచ్చు: డిఫాల్ట్ కాన్ఫిగర్‌లో అభివృద్ధిని నిర్వహించండి, ఆపై ఆదేశంతో దశకు వెళ్లండి run (అదే ప్రక్రియ dev, కేవలం మార్పులను పర్యవేక్షించదు), వేరే కాన్ఫిగర్‌ని ఉపయోగిస్తుంది.

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

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

మరియు లో ఈ ప్రచురణ Weaveworks నుండి మీరు ఉత్పత్తి కోసం పైప్‌లైన్‌ను సృష్టించే ఉదాహరణను కనుగొనవచ్చు.

తీర్మానం

స్కాఫోల్డ్ అనేది పైప్‌లైన్‌లను నిర్మించడానికి అనుకూలమైన సాధనం, ఇది కుబెర్నెట్‌లకు అప్లికేషన్‌లను అందజేస్తుంది మరియు ప్రధానంగా అభివృద్ధి అవసరాలపై దృష్టి పెడుతుంది. డెవలపర్ యొక్క ప్రాథమిక అవసరాలను పరిగణనలోకి తీసుకునే "చిన్న" పైప్‌లైన్‌ను సృష్టించడం చాలా సులభం, కానీ కావాలనుకుంటే, మీరు పెద్ద ప్రక్రియలను నిర్వహించవచ్చు. CI/CD ప్రాసెస్‌లలో స్కాఫోల్డ్‌ని ఉపయోగించడం యొక్క స్పష్టమైన ఉదాహరణలలో ఒకటి ఇవ్వబడింది అటువంటి పరీక్ష ప్రాజెక్ట్ Kubernetes, gRPC, Istio మరియు OpenCensus ట్రేసింగ్ సామర్థ్యాలను ఉపయోగించి 10 మైక్రోసర్వీస్‌లు.

స్కాఫోల్డ్ ఇప్పటికే GitHubలో దాదాపు 8000+ నక్షత్రాలను కలిగి ఉంది, Google ద్వారా అభివృద్ధి చేయబడింది మరియు ఇందులో భాగం GoogleContainerTools - సాధారణంగా, ప్రాజెక్ట్ ఎప్పటికీ సంతోషంగా అభివృద్ధి చెందుతుందని నమ్మడానికి ప్రతి కారణం ఉంది.

PS

మా బ్లాగులో కూడా చదవండి:

మూలం: www.habr.com

ఒక వ్యాఖ్యను జోడించండి