Popeye is a utility that scans live Kubernetes cluster and reports potential issues with deployed resources and configurations. It sanitizes your cluster based on what’s deployed and not what’s sitting on disk. By scanning your cluster, it detects misconfigurations and helps you to ensure that best practices are in place, thus preventing future headaches. It aims at reducing the cognitive overload one faces when operating a Kubernetes cluster in the wild. Furthermore, if your cluster employs a metric-server, it reports potential resources over/under allocations and attempts to warn you should your cluster run out of capacity.
Popeye is a readonly tool, it does not alter any of your Kubernetes resources in any way!
Popeye is available on Linux, OSX and Windows platforms.
Binaries for Linux, Windows and Mac are available as tarballs in the release page.
For OSX/Unit using Homebrew/LinuxBrew
brew install derailed/popeye/popeye
Building from source Popeye was built using go 1.12+. In order to build Popeye from source you must:
Add the following command in your go.mod file
replace ( github.com/derailed/popeye => MY_POPEYE_CLONED_GIT_REPO )
Build and run the executable
go run main.go
Quick recipe for the impatient:
# Clone outside of GOPATH git clone https://github.com/derailed/popeye cd popeye # Build and install go install # Run popeye
Popeye uses 256 colors terminal mode. On `Nix system make sure TERM is set accordingly.
Popeye scans your cluster for best practices and potential issues. Currently, Popeye only looks at nodes, namespaces, pods and services. More will come soon! We are hoping Kubernetes friends will pitch’in to make Popeye even better.
The aim of the sanitizers is to pick up on misconfigurations, i.e. things like port mismatches, dead or unused resources, metrics utilization, probes, container images, RBAC rules, naked resources, etc…
Popeye is not another static analysis tool. It runs and inspect Kubernetes resources on live clusters and sanitize resources as they are in the wild!
Here is a list of some of the available sanitizers:
|Conditions ie not ready, out of mem/disk, network, pids, etc|
|Pod tolerations referencing node taints|
|CPU/MEM utilization metrics, trips if over limits (default 80% CPU/MEM)|
|CPU/MEM on containers over a set CPU/MEM limit (default 80% CPU/MEM)|
|Container image with no tags|
|Container image using
|Resources request/limits presence|
|Probes liveness/readiness presence|
|Named ports and their references|
|Matching pods labels|
|Named ports and their references|
|Unused, detects potentially unused SAs|
|Unused, detects potentially unused secrets or associated keys|
|Unused, detects potentially unused cm or associated keys|
|Unused, pod template validation, resource utilization|
|Unsed, pod template validation, resource utilization|
|Unsed, pod template validation, resource utilization|
|Unused, check volume bound or volume error|
|Unused, check bounded or volume mount error|
|Unused, Utilization, Max burst checks|
|Unused, Check minAvailable configuration||pdb|
To save the Popeye report to a file pass the
--save flag to the command.
By default it will create a temp directory and will store the report there,
the path of the temp directory will be printed out on STDOUT.
If you have the need to specify the output directory for the report,
you can use the environment variable
Example to save report in working directory:
$ POPEYE_REPORT_DIR=$(pwd) popeye --save
You can also save the generated report to an AWS S3 bucket with providing the flag
--s3-bucket. As parameter you need to provide the name of the S3 bucket where you want to store the report.
To save the report in a bucket subdirectory provide the bucket parameter as
Underlying the AWS Go lib is used which is handling the credential loading. For more information check out the official documentation.
Example to save report to S3:
$ popeye --s3-bucket=NAME-OF-YOUR-S3-BUCKET/OPTIONAL/SUBDIRECTORY --out=json
You don’t have to build and/or install the binary to run popeye: you can just
run it directly from the official docker repo on quay.io. The default command
when you run the docker container is
popeye, so you just need to pass
whatever cli args are normally passed to popeye. To access your clusters, map
your local kube config directory into the container with
$ docker run --rm -it -v $HOME/.kube:/root/.kube \ quay.io/derailed/popeye:latest --context foo -n bar
Running the above docker command with
--rm means that the container gets
deleted when popeye exits. When you use
--save, it will write it to /tmp in
the container and then delete the container when popeye exits, which means you
lose the output. To get around this, map /tmp to the container’s /tmp:
$ docker run --rm -it -v $HOME/.kube:/root/.kube -v /tmp:/tmp \ quay.ioderailed/popeye:latest --context foo -n bar --save /tmp/popeye/sanitizer_foo_1583042166995001900.txt # Docker has exited, and the container has been deleted, but the file # is in your /tmp subdir because you mapped it into the container $ cat /tmp/popeye/sanitizer_foo_1583042166995001900.txt <snip>
You can use Popeye standalone or using a spinach yaml config to tune the sanitizer. Details about the Popeye configuration file are below.
# Dump version info popeye version # Popeye a cluster using your current kubeconfig environment. popeye # Popeye uses a spinach config file of course! aka spinachyaml! popeye -f spinach.yml # Popeye a cluster using a kubeconfig context. popeye --context olive # Stuck? popeye help
Popeye can generate sanitizer reports in a variety of formats. You can use the -o cli option and pick your poison from there.
|standard||The full monty output iconized and colorized||yes|
|jurassic||No icons or color like it’s 1989|
|junit||For the Java melancholic|
|prometheus||Dumps report a prometheus scrappable metrics||dardanel|
|score||Returns a single cluster sanitizer score value (0-100)||kabute|
A spinach.yml configuration file can be specified via the
-f option to further configure the sanitizers. This file may specify
the container utilization threshold and specific sanitizer configurations as well as resources that will be excluded from the sanitization.
NOTE: This file will change as Popeye matures!
A resource is identified by a resource kind and a fully qualified resource name, i.e.
For example, the FQN of a pod named
fred-1234 in the namespace
blee will be
blee/fred-1234. This provides for differentiating
blee/p1. For cluster wide resources, the FQN is equivalent to the name. Exclude rules can have either a straight string match or a regular expression. In the latter case the regular expression must be indicated using the
NOTE! Please be careful with your regex as more resources than expected may get excluded from the report with a loose regex rule. When your cluster resources change, this could lead to a sub-optimal sanitization. Once in a while it might be a good idea to run Popeye „configless“ to make sure you will recognize any new issues that may have arisen in your clusters…
Here is an example spinach file as it stands in this release. There is a fuller eks and aks based spinach file in this repo under
spinach. (BTW: for new comers into the project, might be a great way to contribute by adding cluster specific spinach file PRs…)
# A Popeye sample configuration file popeye: # Checks resources against reported metrics usage. # If over/under these thresholds a sanitization 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: # ConfigMap sanitizer exclusions... v1/configmaps: # Excludes key must match the singular form of the resource. # For instance this rule will exclude all configmaps named fred.v2.3 and fred.v2.4 - name: rx:fred.+\.v\d+ # Namespace sanitizer exclusions... v1/namespaces: # Exclude all fred* namespaces if the namespaces are not found (404), other error codes will be reported! - name: rx:kube codes: - 404 # Exclude all istio* namespaces from being scanned. - name: rx:istio # 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
Alternatively, Popeye is containerized and can be run directly in your Kubernetes clusters as a one-off or CronJob.
Here is a sample setup, please modify per your needs/wants. The manifests for this are in the k8s directory in this repo.
kubectl apply -f k8s/popeye/ns.yml && kubectl apply -f k8s/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: quay.io/derailed/popeye:v0.8.6 imagePullPolicy: IfNotPresent args: - -o - yaml resources: limits: cpu: 500m memory: 100Mi
In order for Popeye to do his work, the signed-in user must have enough RBAC oomph to get/list the resources mentioned above.
Sample Popeye RBAC Rules (please note that those are subject to change.)
--- # 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 - deployments - endpoints - horizontalpodautoscalers - namespaces - nodes - persistentvolumes - persistentvolumeclaims - pods - secrets - serviceaccounts - services - statefulsets 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
The sanitizer report outputs each resource group scanned and their potential issues. The report is color/emoji coded in term of Sanitizer severity levels:
The heading section for each scanned Kubernetes resource provides a summary count for each of the categories above.
The Summary section provides a Popeye Score based on the sanitization pass on the given cluster.
This initial drop is brittle. Popeye will most likely blow up when…
This is work in progress! If there is enough interest in the Kubernetes community, we will enhance per your recommendations/contributions. Also if you dig this effort, please let us know that too!
Popeye sits on top of many of open source projects and libraries. Our sincere appreciations to all the OSS contributors that work nights and weekends to make this project a reality!
© 2020 Imhotep Software LLC. All materials licensed under Apache v2.0