Popeye: कुबरनेटीज लाइव क्लस्टर लिंटर

Popeye एक उपयोगिता है जो लाइव कुबरनेटीज क्लस्टरों को स्कैन करती है और तैनात संसाधनों एवं कॉन्फ़िगरेशन के साथ संभावित समस्याओं की रिपोर्ट करती है। जैसे-जैसे कुबरनेटीज का परिदृश्य बढ़ता है, मनुष्य के लिए उन मेनिफेस्ट और नीतियों की भीड़ को ट्रैक करना चुनौतीपूर्ण होता जा रहा है जो क्लस्टर का संचालन करते हैं। Popeye आपके क्लस्टर को इस आधार पर स्कैन करता है कि क्या तैनात किया गया है, न कि डिस्क पर क्या है। आपके क्लस्टर को लिंट करके, यह गलत कॉन्फ़िगरेशन, पुराने संसाधनों का पता लगाता है और यह सुनिश्चित करने में आपकी सहायता करता है कि सर्वोत्तम प्रथाएँ लागू हों, जिससे भविष्य की समस्याओं को रोका जा सके। इसका उद्देश्य उस संज्ञानात्मक अतिभार को कम करना है जो किसी को वास्तविक दुनिया में कुबरनेटीज क्लस्टर संचालित करते समय सामना करना पड़ता है। इसके अलावा, यदि आपका क्लस्टर मीट्रिक-सर्वर का उपयोग करता है, तो यह संभावित संसाधन अधिक/कम आवंटन की रिपोर्ट करता है और यदि आपके क्लस्टर की क्षमता समाप्त हो जाती है तो आपको चेतावनी देने का प्रयास करता है।

Popeye एक केवल-पढ़ने योग्य उपकरण है, यह किसी भी तरह से आपके कुबरनेटीज संसाधनों में कोई बदलाव नहीं करता है!

codebeat badge GitHub stars

स्क्रीनशॉट

कंसोल

JSON

HTML

आप स्कैन रिपोर्ट को HTML में डंप कर सकते हैं।

ग्राफाना डैशबोर्ड

Popeye Prometheus मीट्रिक प्रकाशित करता है। हमने इस रिपॉजिटरी में आपको शुरू करने के लिए एक नमूना Popeye डैशबोर्ड प्रदान किया है।

स्थापना

Popeye Linux, OSX और Windows प्लेटफार्मों पर उपलब्ध है।

Linux, Windows और Mac के लिए बाइनरी release पेज पर tarballs के रूप में उपलब्ध हैं।
For OSX/Unit using Homebrew/LinuxBrew ```shell brew install derailed/popeye/popeye
go install का उपयोग करके
```
go install github.com/derailed/popeye@latest
```
स्रोत से निर्माण Popeye को go 1.21+ का उपयोग करके बनाया गया है। Popeye को स्रोत से बनाने के लिए आपको यह करना होगा:
1. रिपॉजिटरी क्लोन करें
2. अपनी go.mod फ़ाइल में निम्नलिखित कमांड जोड़ें
```
replace (
  github.com/derailed/popeye => MY_POPEYE_CLONED_GIT_REPO
)
```
3. निष्पादन योग्य बनाएं और चलाएं
```
go run main.go
```
अधीर लोगों के लिए त्वरित नुस्खा: ```shell

Clone outside of GOPATH

git clone https://github.com/derailed/popeye cd popeye

Build and install

make build

Run

popeye

PreFlight Checks

Popeye 256 रंगों वाले टर्मिनल मोड का उपयोग करता है। `Nix सिस्टम पर सुनिश्चित करें कि TERM तदनुसार सेट हो।
```
export TERM=xterm-256color
```

कमांड लाइन

आप Popeye का उपयोग पूरी तरह से खुले रूप में या अपने लिंटर्स को ट्यून करने के लिए spinach yaml कॉन्फ़िग का उपयोग करके कर सकते हैं। Popeye कॉन्फ़िगरेशन फ़ाइल के बारे में विवरण नीचे दिए गए हैं।```shell

Dump version info and logs location

popeye version

Popeye a cluster using your current kubeconfig environment.

NOTE! This will run Popeye in the context namespace if set or like kubectl will use the default namespace

popeye

Run Popeye in the `fred` namespace

popeye -n fred

Run Popeye in all namespaces

popeye -A

Run Popeye uses a spinach config file of course! aka spinachyaml!

popeye -f spinach.yaml

Popeye a cluster using a kubeconfig context.

popeye --context olive

Run Popeye with specific linters and log to the console

popeye -n ns1 -s pod,svc --logs none

Run Popeye for a given namespace in a given log file and debug logs

popeye -n ns1 --logs /tmp/fred.log -v4

Stuck?

popeye help

---

## लिंटर्स

Popeye आपके क्लस्टर को सर्वोत्तम प्रथाओं और संभावित समस्याओं के लिए स्कैन करता है।
वर्तमान में, Popeye केवल कुछ निर्धारित क्यूरेटेड Kubernetes संसाधनों की जाँच करता है।
जल्द ही और भी आएंगे!
हमें उम्मीद है कि Kubernetes के मित्र Popeye को और बेहतर बनाने के लिए इसमें योगदान देंगे।

लिंटर्स का उद्देश्य गलत कॉन्फ़िगरेशन को पकड़ना है, जैसे कि पोर्ट बेमेल, मृत या अप्रयुक्त संसाधन, मीट्रिक उपयोग, प्रोब्स, कंटेनर इमेज, RBAC नियम, नग्न संसाधन आदि।

Popeye कोई अन्य स्थैतिक विश्लेषण उपकरण नहीं है। यह लाइव क्लस्टर पर Kubernetes संसाधनों को चलाता और निरीक्षण करता है तथा संसाधनों की जाँच उनके वास्तविक रूप में करता है!

यहाँ कुछ उपलब्ध लिंटर्स की सूची दी गई है:

|    | संसाधन                  | लिंटर्स                                                                 | उपनाम    |
|----|-------------------------|-------------------------------------------------------------------------|------------|
| 🛀 | Node                    |                                                                         | no         |
|    |                         | स्थितियाँ जैसे तैयार नहीं, मेम/डिस्क/नेटवर्क/पिड्स खत्म, आदि            |            |
|    |                         | पॉड टॉलरेशन जो नोड टेंट्स को संदर्भित करते हैं                         |            |
|    |                         | CPU/MEM उपयोग मीट्रिक, यदि सीमा से अधिक हो (डिफ़ॉल्ट 80% CPU/MEM)       |            |
| 🛀 | Namespace               |                                                                         | ns         |
|    |                         | निष्क्रिय                                                                |            |
|    |                         | मृत नेमस्पेस                                                           |            |
| 🛀 | Pod                     |                                                                         | po         |
|    |                         | पॉड स्थिति                                                             |            |
|    |                         | कंटेनर स्थितियाँ                                                         |            |
|    |                         | ServiceAccount उपस्थिति                                                 |            |
|    |                         | एक निर्धारित CPU/MEM सीमा से अधिक कंटेनरों पर CPU/MEM (डिफ़ॉल्ट 80% CPU/MEM) |            |
|    |                         | बिना टैग के कंटेनर इमेज                                                |            |
|    |                         | `latest` टैग का उपयोग करने वाली कंटेनर इमेज                              |            |
|    |                         | संसाधन अनुरोध/सीमा की उपस्थिति                                           |            |
|    |                         | प्रोब्स लाइवनेस/रेडीनेस की उपस्थिति                                      |            |
|    |                         | नामित पोर्ट और उनके संदर्भ                                                |            |
| 🛀 | Service                 |                                                                         | svc        |
|    |                         | एंडपॉइंट्स की उपस्थिति                                                    |            |
|    |                         | मिलान करने वाले पॉड लेबल                                                  |            |
|    |                         | नामित पोर्ट और उनके संदर्भ                                                |            |
| 🛀 | ServiceAccount          |                                                                         | sa         |
|    |                         | अप्रयुक्त, संभावित रूप से अप्रयुक्त SAs का पता लगाता है                    |            |
| 🛀 | Secrets                 |                                                                         | sec        |
|    |                         | अप्रयुक्त, संभावित रूप से अप्रयुक्त सीक्रेट या संबद्ध कुंजियों का पता लगाता है |            |
| 🛀 | ConfigMap               |                                                                         | cm         |
|    |                         | अप्रयुक्त, संभावित रूप से अप्रयुक्त cm या संबद्ध कुंजियों का पता लगाता है      |            |
| 🛀 | Deployment              |                                                                         | dp, deploy |
|    |                         | अप्रयुक्त, पॉड टेम्पलेट सत्यापन, संसाधन उपयोग                           |            |
| 🛀 | StatefulSet             |                                                                         | sts        |
|    |                         | अप्रयुक्त, पॉड टेम्पलेट सत्यापन, संसाधन उपयोग                           |            |
| 🛀 | DaemonSet               |                                                                         | ds         |
|    |                         | अप्रयुक्त, पॉड टेम्पलेट सत्यापन, संसाधन उपयोग                           |            |
| 🛀 | PersistentVolume        |                                                                         | pv         |
|    |                         | अप्रयुक्त, वॉल्यूम बाउंड या वॉल्यूम त्रुटि की जाँच करें                   |            |
| 🛀 | PersistentVolumeClaim   |                                                                         | pvc        |
|    |                         | अप्रयुक्त, बाउंडेड या वॉल्यूम माउंट त्रुटि की जाँच करें                  |            |
| 🛀 | HorizontalPodAutoscaler |                                                                         | hpa        |
|    |                         | अप्रयुक्त, उपयोग, अधिकतम बर्स्ट जाँच                                     |            |
| 🛀 | PodDisruptionBudget     |                                                                         |            |
|    |                         | अप्रयुक्त, minAvailable कॉन्फ़िगरेशन की जाँच करें                         | pdb        |
| 🛀 | ClusterRole             |                                                                         |            |
|    |                         | अप्रयुक्त                                                               | cr         |
| 🛀 | ClusterRoleBinding      |                                                                         |            |
|    |                         | अप्रयुक्त                                                               | crb        |
| 🛀 | Role                    |                                                                         |            |
|    |                         | अप्रयुक्त                                                               | ro         |
| 🛀 | RoleBinding             |                                                                         |            |
|    |                         | अप्रयुक्त                                                               | rb         |
| 🛀 | Ingress                 |                                                                         |            |
|    |                         | मान्य                                                                   | ing        |
| 🛀 | NetworkPolicy           |                                                                         |            |
|    |                         | मान्य, अप्रचलित, संरक्षित                                                | np         |
| 🛀 | PodSecurityPolicy       |                                                                         |            |
|    |                         | मान्य                                                                   | psp        |
| 🛀 | Cronjob                 |                                                                         |            |
|    |                         | मान्य, निलंबित, रन्स                                                    | cj         |
| 🛀 | Job                     |                                                                         |            |
|    |                         | पॉड जाँच                                                               | job        |
| 🛀 | GatewayClass            |                                                                         |            |
|    |                         | मान्य, अप्रयुक्त                                                        | gwc        |
| 🛀 | Gateway                 |                                                                         |            |
|    |                         | मान्य, अप्रयुक्त                                                        | gw         |
| 🛀 | HTTPRoute               |                                                                         |            |
|    |                         | मान्य, अप्रयुक्त                                                        | gwr        |

आप [कोड्स की पूरी सूची](https://github.com/derailed/popeye/blob/HEAD/docs/codes.md) भी देख सकते हैं।

---

## स्कैन सहेजना

Popeye रिपोर्ट को फ़ाइल में सहेजने के लिए कमांड में `--save` फ़्लैग पास करें।
डिफ़ॉल्ट रूप से यह एक tmp निर्देशिका बनाएगा और वहाँ आपकी स्कैन रिपोर्ट संग्रहीत करेगा।
tmp निर्देशिका का पथ STDOUT पर मुद्रित किया जाएगा।
यदि आपको रिपोर्ट के लिए आउटपुट निर्देशिका निर्दिष्ट करने की आवश्यकता है,
तो आप इस पर्यावरण चर `POPEYE_REPORT_DIR` का उपयोग कर सकते हैं। अंतिम पथ <POPEYE_REPORT_DIR>/<cluster>/<context> होगा।
डिफ़ॉल्ट रूप से, आउटपुट फ़ाइल का नाम निम्नलिखित प्रारूप का पालन करता है: `lint_<cluster-name>_<time-UnixNano>.<output-extension>` (उदा.: "lint-mycluster-1594019782530851873.html")।
यदि आप रिपोर्ट के लिए आउटपुट फ़ाइल का नाम भी निर्दिष्ट करना चाहते हैं, तो आप `--output-file` फ़्लैग को वांछित फ़ाइल नाम के साथ पास कर सकते हैं।

रिपोर्ट को कार्य निर्देशिका में सहेजने का उदाहरण:```shell
POPEYE_REPORT_DIR=$(pwd) popeye --save

कार्य निर्देशिका में HTML प्रारूप में "report.html" नाम से रिपोर्ट सहेजने का उदाहरण :```shell POPEYE_REPORT_DIR=$(pwd) popeye --save --out html --output-file report.html

### S3 ऑब्जेक्ट स्टोर में सेव करें

वैकल्पिक रूप से, आप फ्लैग `--s3-bucket` प्रदान करके जनरेटेड रिपोर्ट्स को AWS S3 या Minio ऑब्जेक्ट स्टोर पर पुश कर सकते हैं।
पैरामीटर्स के लिए आपको उस S3 बकेट का नाम प्रदान करना होगा जहां आप रिपोर्ट स्टोर करना चाहते हैं।
रिपोर्ट को बकेट की उप-निर्देशिका में सेव करने के लिए बकेट पैरामीटर को `bucket/path/to/report` के रूप में प्रदान करें।

S3 में रिपोर्ट सेव करने का उदाहरण:```shell
# AWS S3
# NOTE: You must provide env vars for AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY
# This will create bucket my-popeye if not present and upload a popeye json report to /fred/scan.json
popeye --s3-bucket s3://my-popeye/fred --s3-region us-west-2 --out json --save --output-file scan.json

# Minio Object Store
# NOTE: You must provide env vars for AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY and a minio server URI
# This will create bucket my-popeye if not present and upload a popeye json report to /fred/scan.json
popeye --s3-bucket minio://my-popeye/fred --s3-region us-east --s3-endpoint localhost:9000 --out json --save --output-file scan.json

Docker समर्थन

आप Popeye को कंटेनर में चला सकते हैं, इसे सीधे Quay पर आधिकारिक docker रेपो से चलाकर। जब आप docker कंटेनर चलाते हैं तो डिफ़ॉल्ट कमांड popeye है, इसलिए आप समर्थित cli फ़्लैग का उपयोग करके स्कैन को अनुकूलित कर सकते हैं। अपने क्लस्टर तक पहुँचने के लिए, अपनी स्थानीय kubeconfig निर्देशिका को कंटेनर में -v के साथ मैप करें :```shell docker run --rm -it -v $HOME/.kube:/root/.kube quay.io/derailed/popeye --context foo -n bar

उपरोक्त डॉकर कमांड को `--rm` के साथ चलाने का मतलब है कि जब Popeye बाहर निकलता है तो कंटेनर हटा दिया जाता है।
जब आप `--save` का उपयोग करते हैं, तो यह कंटेनर के /tmp में लिखेगा और फिर popeye के बाहर निकलने पर कंटेनर को हटा देगा, जिसका मतलब है कि आप आउटपुट खो देंगे ;(
इससे बचने के लिए, /tmp को कंटेनर के /tmp से मैप करें।

> नोट: आप `POPEYE_REPORT_DIR` एनवी वेरिएबल सेट करके डिफ़ॉल्ट आउटपुट डायरेक्टरी स्थान को ओवरराइड कर सकते हैं।```shell
docker run --rm -it \
  -v $HOME/.kube:/root/.kube \
  -e POPEYE_REPORT_DIR=/tmp/popeye \
  -v /tmp:/tmp \
  quay.io/derailed/popeye --context foo -n bar --save --output-file my_report.txt

# Docker has exited, and the container has been deleted, but the file
# is in your /tmp directory because you mapped it into the container
cat /tmp/popeye/my_report.txt
<snip>

आउटपुट प्रारूप

पॉपआई विभिन्न प्रारूपों में लिंटर रिपोर्ट तैयार कर सकता है। आप -o क्ली विकल्प का उपयोग कर सकते हैं और वहां से अपनी पसंद चुन सकते हैं।

प्रॉम क्वीन!

पॉपआई एक स्कैन से सीधे प्रोमेथियस मेट्रिक्स प्रकाशित कर सकता है। आपको प्रोमेथियस पुशगेटवे और क्रेडेंशियल्स तक पहुंच की आवश्यकता होगी।

नोट! ये उपयोगकर्ताओं की प्रतिक्रिया और उपयोग के आधार पर बदल सकते हैं!!

मेट्रिक्स प्रकाशित करने के लिए, अतिरिक्त क्ली आर्ग्स मौजूद होने चाहिए।```shell

Run popeye using console output and push prom metrics.

popeye --push-gtwy-url http://localhost:9091

Run popeye using a saved html output and push prom metrics.

NOTE! When scan are dump to disk, popeye_cluster_score metric below includes

an additional label to track the persisted artifact so you can aggregate with the scan

Don't think it's the correct approach as this changes the metric cardinality on every push.

Hence open for suggestions here??

popeye -o html --save --push-gtwy-url http://localhost:9091

### PopProm मीट्रिक्स

निम्नलिखित Popeye prometheus मीट्रिक्स प्रकाशित किए गए हैं:

* `popeye_severity_total` [gauge] गंभीरता के आधार पर विभिन्न गणनाओं को ट्रैक करता है।
* `popeye_code_total` [gauge] Popeye के लिंटर कोड द्वारा गणनाओं को ट्रैक करता है।
* `popeye_linter_tally_total` [gauge] प्रति लिंटर गणनाओं को ट्रैक करता है।
* `popeye_report_errors_total` [gauge] स्कैन त्रुटियों की कुल संख्या को ट्रैक करता है।
* `popeye_cluster_score` [gauge] स्कैन रिपोर्ट स्कोर को ट्रैक करता है।


### PopGraf

आपको शुरू करने के लिए इस रेपो में एक नमूना [Grafana](https://grafana.com) डैशबोर्ड पाया जा सकता है।

> नोट! कार्य प्रगति पर है, यदि आपके पास UX/grafana/promql कौशल है तो कृपया योगदान करने में संकोच न करें।


---

## SpinachYAML

एक spinach YAML कॉन्फ़िगरेशन फ़ाइल को `-f` विकल्प के माध्यम से निर्दिष्ट किया जा सकता है ताकि लिंटर्स को और कॉन्फ़िगर किया जा सके। यह फ़ाइल कंटेनर उपयोग सीमा और विशिष्ट लिंटर कॉन्फ़िगरेशन के साथ-साथ उन संसाधनों और कोडों को निर्दिष्ट कर सकती है जिन्हें लिंटर से बाहर रखा जाएगा।

> नोट! यह फ़ाइल Popeye के परिपक्व होने के साथ बदल जाएगी!

`excludes` कुंजी के अंतर्गत आप कुछ संसाधनों या लिंटर कोड को छोड़ने के लिए कॉन्फ़िगर कर सकते हैं। Popeye के लिंटर्स का नाम k8s संसाधन नामों पर रखा गया है। उदाहरण के लिए PodDisruptionBudget लिंटर का नाम `poddisruptionbudgets` है और यह `policy/v1/poddisruptionbudgets` को स्कैन करता है।

> नोट! लिंटर बहुवचन संसाधन `kind` फॉर्म का उपयोग करता है और सब कुछ लोअरकेस में लिखा जाता है।

एक संसाधन पूर्ण योग्य नाम उर्फ `FQN` का उपयोग spinach फ़ाइल में एक संसाधन नाम की पहचान करने के लिए किया जाता है, अर्थात `namespace/resource_name`।

उदाहरण के लिए, नेमस्पेस `blee` में `fred-1234` नामक पॉड का FQN `blee/fred-1234` होगा। यह `fred/p1` और `blee/p1` के बीच अंतर करने में सक्षम बनाता है। क्लस्टर-व्यापी संसाधनों के लिए, FQN नाम के बराबर है। बहिष्करण नियम या तो एक सीधा स्ट्रिंग मैच या एक रेगुलर एक्सप्रेशन हो सकते हैं। बाद के मामले में, रेगुलर एक्सप्रेशन को `rx:` उपसर्ग के माध्यम से निर्दिष्ट किया जाना चाहिए।

> नोट! कृपया अपने regex से सावधान रहें क्योंकि एक *ढीले* regex नियम से अपेक्षा से अधिक संसाधन रिपोर्ट से बाहर हो सकते हैं।
> जब आपके क्लस्टर संसाधन बदलते हैं, तो इससे उप-इष्टतम स्कैन हो सकते हैं।
> इस प्रकार हम अनुशंसा करते हैं कि कभी-कभी Popeye को `wide open` चलाएं ताकि यह सुनिश्चित हो सके कि आप अपने क्लस्टर में उत्पन्न होने वाले किसी भी नए मुद्दे को पकड़ लेंगे…

यहाँ इस रिलीज़ में एक उदाहरण spinach फ़ाइल है। इस रेपो में `spinakh` के अंतर्गत एक अधिक पूर्ण eks और aks आधारित spinach फ़ाइल है। (BTW: प्रोजेक्ट में नए लोगों के लिए, क्लस्टर-विशिष्ट spinach फ़ाइल PR जोड़कर योगदान करने का यह एक शानदार तरीका हो सकता है...)```yaml
# spinach.yaml

# A Popeye sample configuration file
popeye:
  # Checks resources against reported metrics usage.
  # If over/under these thresholds a linter warning will be issued.
  # Your cluster must run a metrics-server for these to take place!
  allocations:
    cpu:
      underPercUtilization: 200 # Checks if cpu is under allocated by more than 200% at current load.
      overPercUtilization: 50   # Checks if cpu is over allocated by more than 50% at current load.
    memory:
      underPercUtilization: 200 # Checks if mem is under allocated by more than 200% at current load.
      overPercUtilization: 50   # Checks if mem is over allocated by more than 50% usage at current load.

  # Excludes excludes certain resources from Popeye scans
  excludes:
    # [NEW!] Global exclude resources and codes globally of any linters.
    global:
      fqns: [rx:^kube-] # => excludes all resources in kube-system, kube-public, etc..
      # [NEW!] Exclude resources for all linters matching these labels
      labels:
        app: [bozo, bono] #=> exclude any resources with labels matching either app=bozo or app=bono
      # [NEW!] Exclude resources for all linters matching these annotations
      annotations:
        fred: [blee, duh] # => exclude any resources with annotations matching either fred=blee or fred=duh
      # [NEW!] Exclude scan codes globally via straight codes or regex!
      codes: ["300", "206", "rx:^41"] # => exclude issue codes 300, 206, 410, 415 (Note: regex match!)

    # [NEW!] Configure individual resource linters
    linters:
      # Configure the namespaces linter for v1/namespaces
      namespaces:
        # [NEW!] Exclude these codes for all namespace resources straight up or via regex.
        codes: ["100", "rx:^22"] # => exclude codes 100, 220, 225, ...
        # [NEW!] Excludes specific namespaces from the scan
        instances:
          - fqns: [kube-public, kube-system] # => skip ns kube-pulbic and kube-system
          - fqns: [blee-ns]
            codes: [106] # => skip code 106 for namespace blee-ns

      # Skip secrets in namespace bozo.
      secrets:
        instances:
          - fqns: [rx:^bozo]

      # Configure the pods linter for v1/pods.
      pods:
        instances:
          # [NEW!] exclude all pods matching these labels.
          - labels:
              app: [fred,blee] # Exclude codes 102, 105 for any pods with labels app=fred or app=blee
            codes: [102, 105]

  resources:
    # Configure node resources.
    node:
      # Limits set a cpu/mem threshold in % ie if cpu|mem > limit a lint warning is triggered.
      limits:
        # CPU checks if current CPU utilization on a node is greater than 90%.
        cpu:    90
        # Memory checks if current Memory utilization on a node is greater than 80%.
        memory: 80

    # Configure pod resources
    pod:
      # Restarts check the restarts count and triggers a lint warning if above threshold.
      restarts: 3
      # Check container resource utilization in percent.
      # Issues a lint warning if about these threshold.
      limits:
        cpu:    80
        memory: 75


  # [New!] overrides code severity
  overrides:
    # Code specifies a custom severity level ie critical=3, warn=2, info=1
    - code: 206
      severity: 1

  # Configure a list of allowed registries to pull images from.
  # Any resources not using the following registries will be flagged!
  registries:
    - quay.io
    - docker.io

क्लस्टर में

पोपे कंटेनरीकृत है और इसे आपके Kubernetes क्लस्टर में एक बार या क्रोनजॉब के रूप में सीधे चलाया जा सकता है।

यहाँ एक नमूना सेटअप है, कृपया अपनी आवश्यकताओं/इच्छाओं के अनुसार संशोधित करें। इसके मैनिफेस्ट इस रिपॉजिटरी में k8s निर्देशिका में हैं।```shell kubectl apply -f k8s/popeye

इनपुट:```yaml
---
apiVersion: v1
kind: Namespace
metadata:
  name:      popeye
---
apiVersion: batch/v1
kind: CronJob
metadata:
  name:      popeye
  namespace: popeye
spec:
  schedule: "* */1 * * *" # Fire off Popeye once an hour
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      template:
        spec:
          serviceAccountName: popeye
          restartPolicy: Never
          containers:
            - name: popeye
              image: derailed/popeye:vX.Y.Z
              imagePullPolicy: IfNotPresent
              args:
                - -o
                - yaml
                - --force-exit-zero
              resources:
                limits:
                  cpu:    500m
                  memory: 100Mi

--force-exit-zero को सेट किया जाना चाहिए। अन्यथा, पॉड्स एक त्रुटि स्थिति में समाप्त हो जाएंगे।

नोट! यदि कोई लिंट त्रुटियां पाई जाती हैं तो Popeye एक गैर-शून्य त्रुटि कोड के साथ बाहर निकलता है।

Popeye ने आपका RBAC पकड़ लिया!

Popeye को अपना काम करने के लिए, साइन-इन किए गए उपयोगकर्ता के पास ऊपर बताए गए संसाधनों को प्राप्त/सूचीबद्ध करने के लिए पर्याप्त RBAC शक्ति होनी चाहिए।

नमूना Popeye RBAC नियम (कृपया ध्यान दें कि ये परिवर्तन के अधीन हैं।)

नोट! कृपया अपने क्लस्टर नीतियों के अनुसार समीक्षा और ट्यून करें।```yaml

Popeye ServiceAccount.

apiVersion: v1 kind: ServiceAccount metadata: name: popeye namespace: popeye

Popeye needs get/list access on the following Kubernetes resources.

apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: name: popeye rules:

apiGroups: [""] resources:
- configmaps
- endpoints
- namespaces
- nodes
- persistentvolumes
- persistentvolumeclaims
- pods
- secrets
- serviceaccounts
- services verbs: ["get", "list"]
apiGroups: ["apps"] resources:
- daemonsets
- deployments
- statefulsets
- replicasets verbs: ["get", "list"]
apiGroups: ["networking.k8s.io"] resources:
- ingresses
- networkpolicies verbs: ["get", "list"]
apiGroups: ["batch.k8s.io"] resources:
- cronjobs
- jobs verbs: ["get", "list"]
apiGroups: ["gateway.networking.k8s.io"] resources:
- gateway-classes
- gateways
- httproutes verbs: ["get", "list"]
apiGroups: ["autoscaling"] resources:
- horizontalpodautoscalers verbs: ["get", "list"]
apiGroups: ["policy"] resources:
- poddisruptionbudgets
- podsecuritypolicies verbs: ["get", "list"]
apiGroups: ["rbac.authorization.k8s.io"] resources:
- clusterroles
- clusterrolebindings
- roles
- rolebindings verbs: ["get", "list"]
apiGroups: ["metrics.k8s.io"] resources:
- pods
- nodes verbs: ["get", "list"]

Binds Popeye to this ClusterRole.

apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: popeye subjects:

kind: ServiceAccount name: popeye namespace: popeye roleRef: kind: ClusterRole name: popeye apiGroup: rbac.authorization.k8s.io

---

## रिपोर्ट संरचना

लिंट रिपोर्ट प्रत्येक स्कैन किए गए संसाधन समूह और उनकी संभावित समस्याओं को आउटपुट करती है।
रिपोर्ट लिंटर गंभीरता स्तरों के अनुसार रंग/इमोजी कोडित है:

| स्तर | आइकन | जुरासिक | रंग     | विवरण               |
|------|------|---------|---------|---------------------|
| ठीक   | ✅   | OK      | हरा     | खुश!                |
| जानकारी | 🔊   | I       | नीला-हरा | जानकारी के लिए       |
| चेतावनी | 😱   | W       | पीला    | संभावित समस्या      |
| त्रुटि   | 💥   | E       | लाल     | कार्रवाई आवश्यक     |

प्रत्येक स्कैन किए गए Kubernetes संसाधन के लिए शीर्षक अनुभाग ऊपर दी गई प्रत्येक श्रेणी के लिए सारांश गणना प्रदान करता है।

सारांश अनुभाग दिए गए क्लस्टर पर लिंटर पास के आधार पर एक **पोपाई स्कोर** प्रदान करता है।

---

## ज्ञात समस्याएँ

यह प्रारंभिक संस्करण नाजुक है। Popeye संभवतः तब विफल होगा जब…

* आप Kubernetes के पुराने संस्करण चला रहे हैं। Popeye Kubernetes 1.25.X के साथ सबसे अच्छा काम करता है।
* आपके पास अपने क्लस्टर को प्रबंधित करने के लिए पर्याप्त RBAC शक्ति नहीं है (RBAC अनुभाग देखें)

---

## अस्वीकरण

यह कार्य प्रगति पर है! यदि Kubernetes समुदाय में पर्याप्त रुचि है, तो हम आपकी सिफारिशों/योगदानों के अनुसार इसे बेहतर बनाएंगे। साथ ही यदि आपको यह प्रयास पसंद आया, तो कृपया हमें बताएं!

---

## ATTA लड़कियाँ/लड़के!

Popeye कई ओपन सोर्स परियोजनाओं और पुस्तकालयों के ऊपर बैठता है। सभी OSS योगदानकर्ताओं के प्रति हमारी *हार्दिक* कृतज्ञता जो रात-रात भर और सप्ताहांत में काम करके इस परियोजना को वास्तविकता बनाते हैं!

### संपर्क जानकारी

1. **ईमेल**:   [email protected]
2. **ट्विटर**: [@kitesurfer](https://twitter.com/kitesurfer?lang=en)

---

<img src="https://raw.githubusercontent.com/derailed/popeye/master/assets/imhotep_logo.png" width="32" height="auto"/>  &nbsp;© 2025 Imhotep Software LLC.
सभी सामग्री [Apache v2.0](http://www.apache.org/licenses/LICENSE-2.0) के तहत लाइसेंस प्राप्त है।

मानक	पूर्ण मोंटी आउटपुट आइकन और रंगीन	हां
जुरासिक	बिना आइकन या रंग, जैसे यह 1979 का समय हो
yaml	YAML के रूप में
html	HTML के रूप में
json	JSON के रूप में
junit	जावा उदासी के लिए
prometheus	रिपोर्ट को प्रोमेथियस मेट्रिक्स के रूप में डंप करता है		dardanel
स्कोर	एक एकल क्लस्टर लिंटर स्कोर मान (0-100) लौटाता है		kabute