குபெர்னெட்ஸை சரிசெய்வதற்கான காட்சி வழிகாட்டி

குறிப்பு. மொழிபெயர்: இந்த கட்டுரை பொது களத்தில் வெளியிடப்பட்ட திட்டப் பொருட்களின் ஒரு பகுதியாகும் கற்று8கள், பயிற்சி நிறுவனங்கள் மற்றும் தனிப்பட்ட நிர்வாகிகள் Kubernetes உடன் வேலை செய்ய. இதில், திட்ட மேலாளர் டேனியல் போலென்சிக், K8s கிளஸ்டரில் இயங்கும் பயன்பாடுகளில் பொதுவான சிக்கல்கள் ஏற்பட்டால் என்ன நடவடிக்கைகள் எடுக்க வேண்டும் என்பதற்கான காட்சி வழிமுறைகளைப் பகிர்ந்துள்ளார்.

TL;DR: குபெர்னெட்டஸில் வரிசைப்படுத்தலைப் பிழைத்திருத்த உதவும் வரைபடம் இங்கே உள்ளது:

ஒரு கிளஸ்டரில் பிழைகளைக் கண்டறிந்து சரிசெய்வதற்கான பாய்வு விளக்கப்படம். அசல் (ஆங்கிலத்தில்) கிடைக்கும் எம் и படமாக.

Kubernetes க்கு ஒரு பயன்பாட்டைப் பயன்படுத்தும்போது, ​​​​நீங்கள் வரையறுக்க வேண்டிய மூன்று கூறுகள் பொதுவாக உள்ளன:

• பயன்படுத்தல் - இது காய்கள் எனப்படும் பயன்பாட்டின் நகல்களை உருவாக்குவதற்கான ஒரு வகையான செய்முறையாகும்;
• சேவை - காய்களுக்கு இடையில் போக்குவரத்தை விநியோகிக்கும் உள் சுமை சமநிலை;
• உட்செல்வதை - வெளி உலகத்திலிருந்து சேவைக்கு போக்குவரத்து எப்படி வரும் என்பது பற்றிய விளக்கம்.

விரைவான வரைகலை சுருக்கம் இங்கே:

1) குபெர்னெட்ஸில், பயன்பாடுகள் வெளி உலகத்திலிருந்து இரண்டு அடுக்கு சுமை சமநிலைப்படுத்திகள் மூலம் போக்குவரத்தைப் பெறுகின்றன: உள் மற்றும் வெளிப்புறம்.

2) இன்டர்னல் பேலன்சர் சர்வீஸ் என்றும், வெளிப்புறமானது இன்க்ரெஸ் என்றும் அழைக்கப்படுகிறது.

3) வரிசைப்படுத்தல் காய்களை உருவாக்குகிறது மற்றும் அவற்றை கண்காணிக்கிறது (அவை கைமுறையாக உருவாக்கப்படவில்லை).

நீங்கள் ஒரு எளிய பயன்பாட்டை பயன்படுத்த விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம் ஹலோ வேர்ல்ட். அதற்கான YAML உள்ளமைவு இப்படி இருக்கும்:

apiVersion: apps/v1
kind: Deployment # <<<
metadata:
  name: my-deployment
  labels:
    track: canary
spec:
  selector:
    matchLabels:
      any-name: my-app
  template:
    metadata:
      labels:
        any-name: my-app
    spec:
      containers:
      - name: cont1
        image: learnk8s/app:1.0.0
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service # <<<
metadata:
  name: my-service
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    name: app
---
apiVersion: networking.k8s.io/v1beta1
kind: Ingress # <<<
metadata:
  name: my-ingress
spec:
  rules:
  - http:
    paths:
    - backend:
        serviceName: app
        servicePort: 80
      path: /

வரையறை மிகவும் நீளமானது மற்றும் கூறுகள் ஒருவருக்கொருவர் எவ்வாறு தொடர்பு கொள்கின்றன என்பதில் குழப்பமடைவது எளிது.

உதாரணமாக:

• போர்ட் 80ஐ எப்போது பயன்படுத்த வேண்டும், 8080ஐ எப்போது பயன்படுத்த வேண்டும்?
• ஒவ்வொரு சேவைக்கும் முரண்படாத வகையில் புதிய போர்ட்டை உருவாக்க வேண்டுமா?
• லேபிள் பெயர்கள் முக்கியமா? அவை எல்லா இடங்களிலும் ஒரே மாதிரியாக இருக்க வேண்டுமா?

பிழைத்திருத்தத்தில் கவனம் செலுத்துவதற்கு முன், மூன்று கூறுகளும் ஒருவருக்கொருவர் எவ்வாறு தொடர்பு கொள்கின்றன என்பதை நினைவில் கொள்வோம். வரிசைப்படுத்தல் மற்றும் சேவையுடன் ஆரம்பிக்கலாம்.

வரிசைப்படுத்துதலுக்கும் சேவைக்கும் இடையிலான உறவு

நீங்கள் ஆச்சரியப்படுவீர்கள், ஆனால் வரிசைப்படுத்துதலும் சேவையும் எந்த வகையிலும் தொடர்புடையவை அல்ல. அதற்குப் பதிலாக, வரிசைப்படுத்தலைத் தவிர்த்து, சேவை நேரடியாக பாட்களுக்குச் செல்கிறது.

எனவே, Pods மற்றும் சேவைகள் ஒன்றுக்கொன்று எவ்வாறு தொடர்புடையது என்பதில் நாங்கள் ஆர்வமாக உள்ளோம். நினைவில் கொள்ள வேண்டிய மூன்று விஷயங்கள்:

1. தேர்வாளர் (selector) சேவைக்கு குறைந்தபட்சம் ஒரு Pod லேபிளுடன் பொருந்த வேண்டும்.
2. targetPort பொருந்தியாக வேண்டும் containerPort பாட் உள்ளே கொள்கலன்.
3. port சேவை எதுவாகவும் இருக்கலாம். வெவ்வேறு சேவைகள் வெவ்வேறு IP முகவரிகளைக் கொண்டிருப்பதால் ஒரே போர்ட்டைப் பயன்படுத்தலாம்.

பின்வரும் வரைபடம் மேலே உள்ள அனைத்தையும் வரைகலை வடிவத்தில் பிரதிபலிக்கிறது:

1) சேவையானது போக்குவரத்தை ஒரு குறிப்பிட்ட பாட்க்கு வழிநடத்துகிறது என்று கற்பனை செய்து பாருங்கள்:

2) ஒரு பாட் உருவாக்கும் போது, ​​நீங்கள் குறிப்பிட வேண்டும் containerPort காய்களில் உள்ள ஒவ்வொரு கொள்கலனுக்கும்:

3) ஒரு சேவையை உருவாக்கும் போது, ​​நீங்கள் குறிப்பிட வேண்டும் port и targetPort. ஆனால் கொள்கலனுடன் இணைக்க எது பயன்படுத்தப்படுகிறது?

4) வழியாக targetPort. இது பொருந்த வேண்டும் containerPort.

5) கொள்கலனில் போர்ட் 3000 திறக்கப்பட்டுள்ளது என்று வைத்துக்கொள்வோம் targetPort ஒரே மாதிரியாக இருக்க வேண்டும்.

YAML கோப்பில், லேபிள்கள் மற்றும் ports / targetPort பொருந்தியாக வேண்டும்:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    track: canary
spec:
  selector:
    matchLabels:
      any-name: my-app
  template:
    metadata:
     labels:  # <<<
        any-name: my-app  # <<<
   spec:
      containers:
      - name: cont1
        image: learnk8s/app:1.0.0
        ports:
       - containerPort: 8080  # <<<
---
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  ports:
  - port: 80
   targetPort: 8080  # <<<
 selector:  # <<<
    any-name: my-app  # <<<

லேபிள் பற்றி என்ன track: canary வரிசைப்படுத்தல் பிரிவின் மேலே? அது பொருந்த வேண்டுமா?

இந்த லேபிள் வரிசைப்படுத்தல் குறிப்பிட்டது மற்றும் போக்குவரத்தை வழிநடத்த சேவையால் பயன்படுத்தப்படவில்லை. வேறு வார்த்தைகளில் கூறுவதானால், அதை அகற்றலாம் அல்லது வேறு மதிப்பை ஒதுக்கலாம்.

தேர்வாளர் பற்றி என்ன matchLabels?

இது எப்போதும் Pod இன் லேபிள்களுடன் பொருந்த வேண்டும், இது காய்களைக் கண்காணிக்க வரிசைப்படுத்துதலால் பயன்படுத்தப்படுகிறது.

நீங்கள் சரியான திருத்தங்களைச் செய்துள்ளீர்கள் என்று வைத்துக்கொள்வோம். அவற்றை எவ்வாறு சரிபார்க்க வேண்டும்?

பின்வரும் கட்டளையுடன் பாட் லேபிளை நீங்கள் சரிபார்க்கலாம்:

kubectl get pods --show-labels

அல்லது, காய்கள் பல பயன்பாடுகளைச் சேர்ந்தவை என்றால்:

kubectl get pods --selector any-name=my-app --show-labels

எங்கே any-name=my-app ஒரு முத்திரை any-name: my-app.

ஏதேனும் சிரமங்கள் உள்ளனவா?

நீங்கள் பாட் இணைக்க முடியும்! இதைச் செய்ய, நீங்கள் கட்டளையைப் பயன்படுத்த வேண்டும் port-forward kubectl இல். சேவையுடன் இணைக்க மற்றும் இணைப்பைச் சரிபார்க்க இது உங்களை அனுமதிக்கிறது.

kubectl port-forward service/<service name> 3000:80

இங்கே:

• service/<service name> - சேவையின் பெயர்; எங்கள் விஷயத்தில் அது my-service;
• 3000 என்பது கணினியில் திறக்கப்பட வேண்டிய போர்ட்;
• 80 - துறையில் குறிப்பிடப்பட்ட போர்ட் port சேவை.

இணைப்பு நிறுவப்பட்டிருந்தால், அமைப்புகள் சரியாக இருக்கும்.

இணைப்பு தோல்வியுற்றால், லேபிள்களில் சிக்கல் உள்ளது அல்லது போர்ட்கள் பொருந்தவில்லை.

சேவை மற்றும் நுழைவு இடையே உறவு

பயன்பாட்டிற்கான அணுகலை வழங்குவதற்கான அடுத்த படி, உள் நுழைவை அமைப்பதை உள்ளடக்கியது. ஒரு சேவையை எப்படிக் கண்டுபிடிப்பது, அதன் பிறகு காய்களைக் கண்டுபிடித்து அவற்றுக்கான நேரடி போக்குவரத்தை எப்படிக் கண்டுபிடிப்பது என்பதை இன்க்ரெஸ் தெரிந்துகொள்ள வேண்டும். பெயர் மற்றும் திறந்த போர்ட் மூலம் தேவையான சேவையை இன்க்ரெஸ் கண்டுபிடிக்கிறது.

நுழைவு மற்றும் சேவையின் விளக்கத்தில் இரண்டு அளவுருக்கள் பொருந்த வேண்டும்:

1. servicePort Ingress அளவுருவுடன் பொருந்த வேண்டும் port சேவையில்;
2. serviceName உள்ளிழுத்தல் துறையில் பொருந்த வேண்டும் name சேவையில்.

பின்வரும் வரைபடம் போர்ட் இணைப்புகளை சுருக்கமாகக் கூறுகிறது:

1) உங்களுக்கு ஏற்கனவே தெரியும், சேவை குறிப்பிட்டதைக் கேட்கிறது port:

2) உட்செலுத்துதல் எனப்படும் அளவுரு உள்ளது servicePort:

3) இந்த அளவுரு (servicePort) எப்போதும் பொருந்த வேண்டும் port சேவை வரையறையில்:

4) சேவையில் போர்ட் 80 குறிப்பிடப்பட்டிருந்தால், அது அவசியம் servicePort 80க்கு சமமாக இருந்தது:

நடைமுறையில், நீங்கள் பின்வரும் வரிகளுக்கு கவனம் செலுத்த வேண்டும்:

apiVersion: v1
kind: Service
metadata:
 name: my-service  # <<<
spec:
  ports:
 - port: 80  # <<<
   targetPort: 8080
  selector:
    any-name: my-app
---
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - http:
    paths:
    - backend:
       serviceName: my-service  # <<<
       servicePort: 80  # <<<
     path: /

Ingress இயங்குகிறதா என்பதை எவ்வாறு சரிபார்க்கலாம்?

நீங்கள் முறையைப் பயன்படுத்தலாம் kubectl port-forward, ஆனால் சேவைக்கு பதிலாக நீங்கள் இன்க்ரஸ் கன்ட்ரோலருடன் இணைக்க வேண்டும்.

முதலில் நீங்கள் இன்க்ரஸ் கன்ட்ரோலருடன் பாட்டின் பெயரைக் கண்டுபிடிக்க வேண்டும்:

kubectl get pods --all-namespaces
NAMESPACE   NAME                              READY STATUS
kube-system coredns-5644d7b6d9-jn7cq          1/1   Running
kube-system etcd-minikube                     1/1   Running
kube-system kube-apiserver-minikube           1/1   Running
kube-system kube-controller-manager-minikube  1/1   Running
kube-system kube-proxy-zvf2h                  1/1   Running
kube-system kube-scheduler-minikube           1/1   Running
kube-system nginx-ingress-controller-6fc5bcc  1/1   Running

Ingress Pod ஐக் கண்டுபிடித்து (அது வேறு பெயர்வெளியில் இருக்கலாம்) மற்றும் கட்டளையை இயக்கவும் describeபோர்ட் எண்களைக் கண்டறிய:

kubectl describe pod nginx-ingress-controller-6fc5bcc 
--namespace kube-system 
 | grep Ports
Ports:         80/TCP, 443/TCP, 18080/TCP

இறுதியாக, பாட் உடன் இணைக்கவும்:

kubectl port-forward nginx-ingress-controller-6fc5bcc 3000:80 --namespace kube-system

இப்போது ஒவ்வொரு முறையும் உங்கள் கணினியில் போர்ட் 3000க்கு ஒரு கோரிக்கையை அனுப்பினால், அது இன்க்ரஸ் கன்ட்ரோலருடன் போர்ட் 80 க்கு அனுப்பப்படும். செல்வதன் மூலம் http://localhost:3000, பயன்பாட்டினால் உருவாக்கப்பட்ட பக்கத்தை நீங்கள் பார்க்க வேண்டும்.

துறைமுகங்களின் சுருக்கம்

எந்த போர்ட்கள் மற்றும் லேபிள்கள் பொருந்த வேண்டும் என்பதை மீண்டும் நினைவில் கொள்வோம்:

1. சேவை வரையறையில் உள்ள தேர்வாளர் பாட்டின் லேபிளுடன் பொருந்த வேண்டும்;
2. targetPort வரையறையில் சேவை பொருந்த வேண்டும் containerPort ஒரு நெற்றுக்குள் கொள்கலன்;
3. port வரையறையில் சேவை எதுவாகவும் இருக்கலாம். வெவ்வேறு சேவைகள் வெவ்வேறு IP முகவரிகளைக் கொண்டிருப்பதால் ஒரே போர்ட்டைப் பயன்படுத்தலாம்;
4. servicePort உட்செலுத்துதல் பொருந்த வேண்டும் port சர்வீஸ் வரையறையில்;
5. சேவையின் பெயர் புலத்துடன் பொருந்த வேண்டும் serviceName உள்ளிழுப்பில்.

துரதிர்ஷ்டவசமாக, YAML உள்ளமைவை எவ்வாறு சரியாகக் கட்டமைப்பது என்பதை அறிவது போதாது.

விஷயங்கள் தவறாக நடக்கும்போது என்ன நடக்கும்?

பாட் தொடங்காமல் இருக்கலாம் அல்லது அது செயலிழந்து போகலாம்.

குபெர்னெட்டஸில் பயன்பாட்டுச் சிக்கல்களைக் கண்டறிவதற்கான 3 படிகள்

உங்கள் வரிசைப்படுத்தலைப் பிழைத்திருத்தத் தொடங்கும் முன், குபெர்னெட்ஸ் எவ்வாறு செயல்படுகிறது என்பதை நீங்கள் நன்கு புரிந்து கொள்ள வேண்டும்.

K8s இல் பதிவிறக்கம் செய்யப்பட்ட ஒவ்வொரு பயன்பாடும் மூன்று கூறுகளைக் கொண்டிருப்பதால், அவை ஒரு குறிப்பிட்ட வரிசையில் பிழைத்திருத்தப்பட வேண்டும், மிகக் கீழே இருந்து தொடங்கி.

1. முதலில் நீங்கள் காய்கள் வேலை செய்கிறதா என்பதை உறுதி செய்ய வேண்டும், பின்னர் ...
2. சேவையானது காய்களுக்கு போக்குவரத்தை வழங்குகிறதா என்பதைச் சரிபார்த்து, பின்னர்...
3. நுழைவு சரியாக உள்ளமைக்கப்பட்டுள்ளதா என சரிபார்க்கவும்.

காட்சி பிரதிநிதித்துவம்:

1) நீங்கள் கீழே இருந்து பிரச்சனைகளை தேட ஆரம்பிக்க வேண்டும். காய்களுக்கு நிலைகள் உள்ளதா என்பதை முதலில் சரிபார்க்கவும் Ready и Running:

2) காய்கள் தயாராக இருந்தால் (Ready), சேவையானது காய்களுக்கு இடையே போக்குவரத்தை விநியோகிக்கிறதா என்பதை நீங்கள் கண்டுபிடிக்க வேண்டும்:

3) இறுதியாக, நீங்கள் சேவை மற்றும் நுழைவு இடையே உள்ள தொடர்பை பகுப்பாய்வு செய்ய வேண்டும்:

1. காய்களைக் கண்டறிதல்

பெரும்பாலான சந்தர்ப்பங்களில் பிரச்சனை நெற்று தொடர்பானது. காய்கள் பட்டியலிடப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும் Ready и Running. கட்டளையைப் பயன்படுத்தி இதைச் சரிபார்க்கலாம்:

kubectl get pods
NAME                    READY STATUS            RESTARTS  AGE
app1                    0/1   ImagePullBackOff  0         47h
app2                    0/1   Error             0         47h
app3-76f9fcd46b-xbv4k   1/1   Running           1         47h

மேலே உள்ள கட்டளை வெளியீட்டில், கடைசி பாட் என பட்டியலிடப்பட்டுள்ளது Running и Ready, இருப்பினும், இது மற்ற இரண்டிற்கும் இல்லை.

என்ன தவறு என்று புரிந்து கொள்வது எப்படி?

காய்களைக் கண்டறிய நான்கு பயனுள்ள கட்டளைகள் உள்ளன:

1. kubectl logs <имя pod'а> ஒரு பெட்டியில் உள்ள கொள்கலன்களிலிருந்து பதிவுகளைப் பிரித்தெடுக்க உங்களை அனுமதிக்கிறது;
2. kubectl describe pod <имя pod'а> பாட் உடன் தொடர்புடைய நிகழ்வுகளின் பட்டியலைக் காண உங்களை அனுமதிக்கிறது;
3. kubectl get pod <имя pod'а> Kubernetes இல் சேமிக்கப்பட்ட ஒரு பாட்டின் YAML உள்ளமைவைப் பெற உங்களை அனுமதிக்கிறது;
4. kubectl exec -ti <имя pod'а> bash பாட் கொள்கலன்களில் ஒன்றில் ஊடாடும் கட்டளை ஷெல்லைத் தொடங்க உங்களை அனுமதிக்கிறது

நீங்கள் எதை தேர்வு செய்ய வேண்டும்?

உண்மை என்னவென்றால், உலகளாவிய கட்டளை இல்லை. இவற்றின் கலவையைப் பயன்படுத்த வேண்டும்.

வழக்கமான நெற்று பிரச்சனைகள்

பாட் பிழைகளில் இரண்டு முக்கிய வகைகள் உள்ளன: தொடக்கப் பிழைகள் மற்றும் இயக்க நேரப் பிழைகள்.

தொடக்கப் பிழைகள்:

• ImagePullBackoff
• ImageInspectError
• ErrImagePull
• ErrImageNeverPull
• RegistryUnavailable
• InvalidImageName

இயக்க நேர பிழைகள்:

• CrashLoopBackOff
• RunContainerError
• KillContainerError
• VerifyNonRootError
• RunInitContainerError
• CreatePodSandboxError
• ConfigPodSandboxError
• KillPodSandboxError
• SetupNetworkError
• TeardownNetworkError

சில பிழைகள் மற்றவர்களை விட மிகவும் பொதுவானவை. மிகவும் பொதுவான சில பிழைகள் மற்றும் அவற்றை எவ்வாறு சரிசெய்வது என்பது இங்கே.

ImagePullBackOff

குபெர்னெட்டஸால் பாட் கொள்கலன்களில் ஒன்றின் படத்தைப் பெற முடியாதபோது இந்தப் பிழை ஏற்படுகிறது. இதற்கு மிகவும் பொதுவான மூன்று காரணங்கள் இங்கே:

1. படத்தின் பெயர் தவறானது - உதாரணமாக, நீங்கள் அதில் தவறு செய்துள்ளீர்கள் அல்லது படம் இல்லை;
2. படத்திற்கு இல்லாத குறிச்சொல் குறிப்பிடப்பட்டது;
3. படம் ஒரு தனியார் பதிவேட்டில் சேமிக்கப்பட்டுள்ளது மற்றும் அதை அணுக குபெர்னெட்டஸுக்கு அனுமதி இல்லை.

முதல் இரண்டு காரணங்களை நீக்குவது எளிது - படத்தின் பெயரையும் குறிச்சொல்லையும் சரிசெய்யவும். பிந்தைய விஷயத்தில், மூடிய பதிவேடுக்கான நற்சான்றிதழ்களை நீங்கள் ரகசியத்தில் உள்ளிட வேண்டும் மற்றும் அதன் இணைப்புகளை காய்களில் சேர்க்க வேண்டும். குபெர்னெட்ஸ் ஆவணத்தில் ஒரு உதாரணம் உள்ளது இதை எப்படி செய்ய முடியும்.

க்ராஷ் லூப் பேக் ஆஃப்

குபெனெட்ஸ் ஒரு பிழையை வீசுகிறார் CrashLoopBackOff, கொள்கலன் தொடங்க முடியவில்லை என்றால். இது வழக்கமாக நடக்கும் போது:

1. பயன்பாட்டில் ஒரு பிழை உள்ளது, அது தொடங்குவதைத் தடுக்கிறது;
2. கொள்கலன் தவறாக உள்ளமைக்கப்பட்டது;
3. லைவ்னெஸ் சோதனை பலமுறை தோல்வியடைந்தது.

அதன் தோல்விக்கான காரணத்தைக் கண்டறிய, கொள்கலனில் இருந்து பதிவுகளைப் பெற முயற்சிக்க வேண்டும். கொள்கலன் மிக விரைவாக மறுதொடக்கம் செய்யப்படுவதால், பதிவுகளை அணுகுவது கடினமாக இருந்தால், பின்வரும் கட்டளையைப் பயன்படுத்தலாம்:

kubectl logs <pod-name> --previous

இது கொள்கலனின் முந்தைய அவதாரத்திலிருந்து பிழை செய்திகளைக் காட்டுகிறது.

RunContainerError

கொள்கலன் தொடங்கத் தவறினால் இந்த பிழை ஏற்படுகிறது. இது பயன்பாடு தொடங்கப்படுவதற்கு முந்தைய தருணத்திற்கு ஒத்திருக்கிறது. இது பொதுவாக தவறான அமைப்புகளால் ஏற்படுகிறது, எடுத்துக்காட்டாக:

• ConfigMap அல்லது Secrets போன்ற இல்லாத தொகுதியை ஏற்ற முயற்சிப்பது;
• படிக்க-எழுது என படிக்க மட்டுமேயான தொகுதியை ஏற்ற முயற்சிக்கவும்.

அத்தகைய பிழைகளை பகுப்பாய்வு செய்வதற்கு குழு மிகவும் பொருத்தமானது kubectl describe pod <pod-name>.

காய்கள் நிலுவையில் உள்ளன

உருவாக்கப்பட்டவுடன், காய் நிலையிலேயே இருக்கும் Pending.

ஏன் இது நடக்கிறது?

சாத்தியமான காரணங்கள் இங்கே உள்ளன (திட்டமிடுபவர் நன்றாக வேலை செய்கிறார் என்று நான் கருதுகிறேன்):

1. க்ளஸ்டரில் பாட் இயக்குவதற்கு, செயலாக்க சக்தி மற்றும் நினைவகம் போன்ற போதுமான ஆதாரங்கள் இல்லை.
2. பொருள் பொருத்தமான பெயர்வெளியில் நிறுவப்பட்டுள்ளது ResourceQuota மற்றும் ஒரு பாட் உருவாக்கினால் பெயர்வெளி ஒதுக்கீட்டிற்கு அப்பால் செல்லும்.
3. பாட் நிலுவையில் உள்ளது PersistentVolumeClaim.

இந்த வழக்கில், கட்டளையைப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது kubectl describe மற்றும் பகுதியை சரிபார்க்கவும் Events:

kubectl describe pod <pod name>

தொடர்பான பிழைகள் ஏற்பட்டால் ResourceQuotas, கட்டளையைப் பயன்படுத்தி கிளஸ்டர் பதிவுகளைப் பார்க்க பரிந்துரைக்கப்படுகிறது

kubectl get events --sort-by=.metadata.creationTimestamp

காய்கள் தயாராக இல்லை

பாட் என பட்டியலிடப்பட்டால் Running, ஆனால் ஒரு நிலையில் இல்லை Ready, அதன் தயார்நிலையை சரிபார்க்கிறது (ஆயத்த ஆய்வு) தோல்வி அடைகிறது.

இது நிகழும்போது, ​​சேவையுடன் பாட் இணைக்கப்படாது மற்றும் அதற்கு எந்த போக்குவரத்தும் செல்லாது. பயன்பாட்டில் உள்ள சிக்கல்களால் தயார்நிலை சோதனை தோல்வி ஏற்படுகிறது. இந்த வழக்கில், பிழையைக் கண்டறிய, நீங்கள் பிரிவை பகுப்பாய்வு செய்ய வேண்டும் Events கட்டளை வெளியீட்டில் kubectl describe.

2. சேவை கண்டறிதல்

காய்கள் என பட்டியலிடப்பட்டால் Running и Ready, ஆனால் பயன்பாட்டிலிருந்து இன்னும் பதில் இல்லை, நீங்கள் சேவை அமைப்புகளை சரிபார்க்க வேண்டும்.

லேபிள்களைப் பொறுத்து காய்களுக்கு போக்குவரத்தை வழிநடத்துவதற்கு சேவைகள் பொறுப்பாகும். எனவே, நீங்கள் செய்ய வேண்டிய முதல் விஷயம், சேவையில் எத்தனை காய்கள் வேலை செய்கின்றன என்பதைச் சரிபார்க்க வேண்டும். இதைச் செய்ய, சேவையின் இறுதிப் புள்ளிகளை நீங்கள் சரிபார்க்கலாம்:

kubectl describe service <service-name> | grep Endpoints

எண்ட்பாயிண்ட் என்பது படிவத்தின் ஒரு ஜோடி மதிப்புகள் <IP-адрес:порт>, மற்றும் குறைந்தபட்சம் அத்தகைய ஜோடி வெளியீட்டில் இருக்க வேண்டும் (அதாவது, சேவையுடன் குறைந்தது ஒரு பாட் வேலை செய்கிறது).

பிரிவு என்றால் Endpoins வெற்று, இரண்டு விருப்பங்கள் சாத்தியம்:

1. சரியான லேபிளுடன் காய்கள் எதுவும் இல்லை (குறிப்பு: பெயர்வெளி சரியாக தேர்ந்தெடுக்கப்பட்டுள்ளதா என சரிபார்க்கவும்);
2. தேர்வியில் உள்ள சேவை லேபிள்களில் பிழை உள்ளது.

நீங்கள் இறுதிப்புள்ளிகளின் பட்டியலைக் கண்டாலும், இன்னும் பயன்பாட்டை அணுக முடியவில்லை என்றால், ஒருவேளை குற்றவாளி ஒரு பிழையாக இருக்கலாம் targetPort சேவை விளக்கத்தில்.

சேவையின் செயல்பாட்டை எவ்வாறு சரிபார்க்கலாம்?

சேவையின் வகையைப் பொருட்படுத்தாமல், நீங்கள் கட்டளையைப் பயன்படுத்தலாம் kubectl port-forward அதனுடன் இணைக்க:

kubectl port-forward service/<service-name> 3000:80

இங்கே:

• <service-name> - சேவையின் பெயர்;
• 3000 என்பது நீங்கள் கணினியில் திறக்கும் போர்ட்;
• 80 - சேவை பக்கத்தில் போர்ட்.

3. நுழைவு கண்டறிதல்

நீங்கள் இதுவரை படித்திருந்தால்:

• காய்கள் பட்டியலிடப்பட்டுள்ளன Running и Ready;
• இந்த சேவை காய்களுக்கு இடையே போக்குவரத்தை வெற்றிகரமாக விநியோகிக்கிறது.

இருப்பினும், நீங்கள் இன்னும் பயன்பாட்டை அடைய முடியவில்லை.

அதாவது Ingress controller சரியாக உள்ளமைக்கப்படவில்லை. இங்க்ரஸ் கன்ட்ரோலர் கிளஸ்டரில் மூன்றாம் தரப்பு கூறு என்பதால், அதன் வகையைப் பொறுத்து வெவ்வேறு பிழைத்திருத்த முறைகள் உள்ளன.

ஆனால் நீங்கள் நுழைவதை உள்ளமைக்க சிறப்பு கருவிகளைப் பயன்படுத்துவதற்கு முன், நீங்கள் மிகவும் எளிமையான ஒன்றைச் செய்யலாம். உட்செலுத்துதல் பயன்படுத்துகிறது serviceName и servicePort சேவையுடன் இணைக்க. அவை சரியாக உள்ளமைக்கப்பட்டுள்ளதா என்பதை நீங்கள் சரிபார்க்க வேண்டும். கட்டளையைப் பயன்படுத்தி இதைச் செய்யலாம்:

kubectl describe ingress <ingress-name>

நெடுவரிசை என்றால் Backend காலியாக உள்ளது, உள்ளமைவு பிழையின் அதிக நிகழ்தகவு உள்ளது. பின்தளங்கள் இடத்தில் இருந்தாலும், பயன்பாட்டை இன்னும் அணுக முடியவில்லை என்றால், சிக்கல் தொடர்புடையதாக இருக்கலாம்:

• பொது இணையத்திலிருந்து அணுகல்தன்மை அமைப்புகளை உட்செலுத்துதல்;
• பொது இணையத்திலிருந்து கிளஸ்டர் அணுகல் அமைப்புகள்.

உள்கட்டமைப்பில் உள்ள சிக்கல்களை நீங்கள் நேரடியாக Ingress Pod உடன் இணைப்பதன் மூலம் கண்டறியலாம். இதைச் செய்ய, முதலில் இன்க்ரெஸ் கன்ட்ரோலர் பாட் (அது வேறு பெயர்வெளியில் இருக்கலாம்):

kubectl get pods --all-namespaces
NAMESPACE   NAME                              READY STATUS
kube-system coredns-5644d7b6d9-jn7cq          1/1   Running
kube-system etcd-minikube                     1/1   Running
kube-system kube-apiserver-minikube           1/1   Running
kube-system kube-controller-manager-minikube  1/1   Running
kube-system kube-proxy-zvf2h                  1/1   Running
kube-system kube-scheduler-minikube           1/1   Running
kube-system nginx-ingress-controller-6fc5bcc  1/1   Running

கட்டளையைப் பயன்படுத்தவும் describeதுறைமுகத்தை அமைக்க:

kubectl describe pod nginx-ingress-controller-6fc5bcc
--namespace kube-system 
 | grep Ports

இறுதியாக, பாட் உடன் இணைக்கவும்:

kubectl port-forward nginx-ingress-controller-6fc5bcc 3000:80 --namespace kube-system

இப்போது கணினியில் போர்ட் 3000க்கான அனைத்து கோரிக்கைகளும் பாட்டின் போர்ட் 80க்கு திருப்பி விடப்படும்.

இப்போது வேலை செய்யுமா?

• ஆம் எனில், பிரச்சனை உள்கட்டமைப்பில் தான். கிளஸ்டருக்கு போக்குவரத்து எவ்வாறு செல்கிறது என்பதை சரியாகக் கண்டறிய வேண்டியது அவசியம்.
• இல்லையெனில், சிக்கல் உள்ளிழுக்கும் கட்டுப்படுத்தியில் உள்ளது.

இங்க்ரஸ் கன்ட்ரோலரை வேலை செய்ய முடியாவிட்டால், அதை பிழைத்திருத்தம் செய்ய வேண்டும்.

நுழைவு கட்டுப்படுத்திகளில் பல வகைகள் உள்ளன. Nginx, HAProxy, Traefik போன்றவை மிகவும் பிரபலமானவை. (தற்போதுள்ள தீர்வுகள் பற்றிய கூடுதல் தகவலுக்கு, பார்க்கவும் எங்கள் விமர்சனம் - தோராயமாக மொழிபெயர்ப்பு.) தொடர்புடைய கட்டுப்பாட்டு ஆவணத்தில் உள்ள சரிசெய்தல் வழிகாட்டியைப் பார்க்க வேண்டும். ஏனெனில் நுழைவு Nginx மிகவும் பிரபலமான இன்க்ரஸ் கன்ட்ரோலர் ஆகும், இது தொடர்பான சிக்கல்களைத் தீர்க்க கட்டுரையில் சில குறிப்புகளைச் சேர்த்துள்ளோம்.

Ingress Nginx கட்டுப்படுத்தி பிழைத்திருத்தம்

Ingress-nginx திட்டத்தில் ஒரு அதிகாரி இருக்கிறார் kubectl க்கான சொருகி. குழு kubectl ingress-nginx இதற்குப் பயன்படுத்தலாம்:

• பதிவுகள், பின்தளங்கள், சான்றிதழ்கள் போன்றவற்றின் பகுப்பாய்வு;
• நுழைவதற்கான இணைப்புகள்;
• தற்போதைய கட்டமைப்பைப் படிக்கிறது.

பின்வரும் மூன்று கட்டளைகள் இதற்கு உங்களுக்கு உதவும்:

• kubectl ingress-nginx lint - காசோலைகள் nginx.conf;
• kubectl ingress-nginx backend - பின்தளத்தை ஆராய்கிறது (இதைப் போன்றது kubectl describe ingress <ingress-name>);
• kubectl ingress-nginx logs - பதிவுகளை சரிபார்க்கிறது.

சில சந்தர்ப்பங்களில் கொடியைப் பயன்படுத்தி நுழைவுக் கட்டுப்படுத்திக்கான சரியான பெயர்வெளியைக் குறிப்பிட வேண்டியிருக்கும். --namespace <name>.

சுருக்கம்

எங்கிருந்து தொடங்குவது என்று உங்களுக்குத் தெரியாவிட்டால், குபெர்னெட்ஸின் சிக்கலைத் தீர்ப்பது சவாலானது. நீங்கள் எப்போதும் கீழே இருந்து பிரச்சனையை அணுக வேண்டும்: காய்களுடன் தொடங்கவும், பின்னர் சேவை மற்றும் உள் நுழைவதற்கு செல்லவும். இந்தக் கட்டுரையில் விவரிக்கப்பட்டுள்ள பிழைத்திருத்த நுட்பங்கள் பிற பொருள்களுக்குப் பயன்படுத்தப்படலாம்:

• செயலற்ற வேலைகள் மற்றும் CronJobs;
• ஸ்டேட்ஃபுல் செட் மற்றும் டெமான்செட்.

எனது நன்றியை தெரிவித்துக் கொள்கிறேன் Gergely Risko, டேனியல் வெய்பெல் и சார்லஸ் கிறிஸ்டிராஜ் மதிப்புமிக்க கருத்துகள் மற்றும் சேர்த்தல்களுக்கு.

மொழிபெயர்ப்பாளரிடமிருந்து பி.எஸ்

எங்கள் வலைப்பதிவிலும் படிக்கவும்:

• «Kubernetes காய்களில் பிழைத்திருத்தத்திற்கான kubectl-debug செருகுநிரல்";
• «குபெர்னெட்டஸின் செயல்பாட்டில் 6 பொழுதுபோக்கு அமைப்பு பிழைகள் [மற்றும் அவற்றின் தீர்வு]";
• «Kubernetes இல் இயங்கும் பயன்பாடுகளை உருவாக்குபவர்களுக்கான கருவிகள்";
• «எங்கள் SRE அன்றாட வாழ்க்கையிலிருந்து 6 நடைமுறைக் கதைகள் ".

ஆதாரம்: www.habr.com