Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/stefanprodan/podinfo

Go microservice template for Kubernetes
https://github.com/stefanprodan/podinfo

cuelang e2e-testing gitops golang helm kubernetes kustomize microservice

Last synced: about 1 month ago
JSON representation

Go microservice template for Kubernetes

Lists

README 

        
# podinfo



[![e2e](https://github.com/stefanprodan/podinfo/workflows/e2e/badge.svg)](https://github.com/stefanprodan/podinfo/blob/master/.github/workflows/e2e.yml)

[![test](https://github.com/stefanprodan/podinfo/workflows/test/badge.svg)](https://github.com/stefanprodan/podinfo/blob/master/.github/workflows/test.yml)

[![cve-scan](https://github.com/stefanprodan/podinfo/workflows/cve-scan/badge.svg)](https://github.com/stefanprodan/podinfo/blob/master/.github/workflows/cve-scan.yml)

[![Go Report Card](https://goreportcard.com/badge/github.com/stefanprodan/podinfo)](https://goreportcard.com/report/github.com/stefanprodan/podinfo)

[![Docker Pulls](https://img.shields.io/docker/pulls/stefanprodan/podinfo)](https://hub.docker.com/r/stefanprodan/podinfo)



Podinfo is a tiny web application made with Go that showcases best practices of running microservices in Kubernetes.

Podinfo is used by CNCF projects like [Flux](https://github.com/fluxcd/flux2) and [Flagger](https://github.com/fluxcd/flagger)

for end-to-end testing and workshops.



Specifications:



* Health checks (readiness and liveness)

* Graceful shutdown on interrupt signals

* File watcher for secrets and configmaps

* Instrumented with Prometheus and Open Telemetry

* Structured logging with zap 

* 12-factor app with viper

* Fault injection (random errors and latency)

* Swagger docs

* Timoni, Helm and Kustomize installers

* End-to-End testing with Kubernetes Kind and Helm

* Multi-arch container image with Docker buildx and GitHub Actions

* Container image signing with Sigstore cosign

* SBOMs and SLSA Provenance embedded in the container image

* CVE scanning with Trivy



Web API:



* `GET /` prints runtime information

* `GET /version` prints podinfo version and git commit hash 

* `GET /metrics` return HTTP requests duration and Go runtime metrics

* `GET /healthz` used by Kubernetes liveness probe

* `GET /readyz` used by Kubernetes readiness probe

* `POST /readyz/enable` signals the Kubernetes LB that this instance is ready to receive traffic

* `POST /readyz/disable` signals the Kubernetes LB to stop sending requests to this instance

* `GET /status/{code}` returns the status code

* `GET /panic` crashes the process with exit code 255

* `POST /echo` forwards the call to the backend service and echos the posted content 

* `GET /env` returns the environment variables as a JSON array

* `GET /headers` returns a JSON with the request HTTP headers

* `GET /delay/{seconds}` waits for the specified period

* `POST /token` issues a JWT token valid for one minute `JWT=$(curl -sd 'anon' podinfo:9898/token | jq -r .token)`

* `GET /token/validate` validates the JWT token `curl -H "Authorization: Bearer $JWT" podinfo:9898/token/validate`

* `GET /configs` returns a JSON with configmaps and/or secrets mounted in the `config` volume

* `POST/PUT /cache/{key}` saves the posted content to Redis

* `GET /cache/{key}` returns the content from Redis if the key exists

* `DELETE /cache/{key}` deletes the key from Redis if exists

* `POST /store` writes the posted content to disk at /data/hash and returns the SHA1 hash of the content

* `GET /store/{hash}` returns the content of the file /data/hash if exists

* `GET /ws/echo` echos content via websockets `podcli ws ws://localhost:9898/ws/echo`

* `GET /chunked/{seconds}` uses `transfer-encoding` type `chunked` to give a partial response and then waits for the specified period

* `GET /swagger.json` returns the API Swagger docs, used for Linkerd service profiling and Gloo routes discovery



gRPC API:



* `/grpc.health.v1.Health/Check` health checking

* `/grpc.EchoService/Echo` echos the received content

* `/grpc.VersionService/Version` returns podinfo version and Git commit hash



Web UI:



![podinfo-ui](https://raw.githubusercontent.com/stefanprodan/podinfo/gh-pages/screens/podinfo-ui-v3.png)



To access the Swagger UI open `/swagger/index.html` in a browser.



### Guides



* [Getting started with Timoni](https://timoni.sh/quickstart/)

* [Getting started with Flux](https://fluxcd.io/flux/get-started/)

* [Progressive Deliver with Flagger and Linkerd](https://docs.flagger.app/tutorials/linkerd-progressive-delivery)

* [Automated canary deployments with Kubernetes Gateway API](https://docs.flagger.app/tutorials/gatewayapi-progressive-delivery)



### Install



To install Podinfo on Kubernetes the minimum required version is **Kubernetes v1.23**.



#### Timoni



Install with [Timoni](https://timoni.sh):



```bash

timoni -n default apply podinfo oci://ghcr.io/stefanprodan/modules/podinfo

```



#### Helm



Install from github.io:



```bash

helm repo add podinfo https://stefanprodan.github.io/podinfo



helm upgrade --install --wait frontend \

--namespace test \

--set replicaCount=2 \

--set backend=http://backend-podinfo:9898/echo \

podinfo/podinfo



helm test frontend --namespace test



helm upgrade --install --wait backend \

--namespace test \

--set redis.enabled=true \

podinfo/podinfo

```



Install from ghcr.io:



```bash

helm upgrade --install --wait podinfo --namespace default \

oci://ghcr.io/stefanprodan/charts/podinfo

```



#### Kustomize



```bash

kubectl apply -k github.com/stefanprodan/podinfo//kustomize

```



#### Docker



```bash

docker run -dp 9898:9898 stefanprodan/podinfo

```



### Continuous Delivery



In order to install podinfo on a Kubernetes cluster and keep it up to date with the latest

release in an automated manner, you can use [Flux](https://fluxcd.io).



Install the Flux CLI on MacOS and Linux using Homebrew:



```sh

brew install fluxcd/tap/flux

```



Install the Flux controllers needed for Helm operations:



```sh

flux install \

--namespace=flux-system \

--network-policy=false \

--components=source-controller,helm-controller

```



Add podinfo's Helm repository to your cluster and

configure Flux to check for new chart releases every ten minutes:



```sh

flux create source helm podinfo \

--namespace=default \

--url=https://stefanprodan.github.io/podinfo \

--interval=10m

```



Create a `podinfo-values.yaml` file locally:



```sh

cat > podinfo-values.yaml <5.0.0" \

--values=podinfo-values.yaml

```



Based on the above definition, Flux will upgrade the release automatically

when a new version of podinfo is released. If the upgrade fails, Flux

can [rollback](https://toolkit.fluxcd.io/components/helm/helmreleases/#configuring-failure-remediation)

to the previous working version.



You can check what version is currently deployed with:



```sh

flux get helmreleases -n default

```



To delete podinfo's Helm repository and release from your cluster run:



```sh

flux -n default delete source helm podinfo

flux -n default delete helmrelease podinfo

```



If you wish to manage the lifecycle of your applications in a **GitOps** manner, check out

this [workflow example](https://github.com/fluxcd/flux2-kustomize-helm-example)

for multi-env deployments with Flux, Kustomize and Helm.