{"id":13465136,"url":"https://github.com/gajus/lightship","last_synced_at":"2025-05-15T17:02:00.427Z","repository":{"id":38857185,"uuid":"139258121","full_name":"gajus/lightship","owner":"gajus","description":"Abstracts readiness, liveness and startup checks and graceful shutdown of Node.js services running in Kubernetes.","archived":false,"fork":false,"pushed_at":"2023-09-01T15:17:36.000Z","size":2138,"stargazers_count":519,"open_issues_count":10,"forks_count":32,"subscribers_count":4,"default_branch":"main","last_synced_at":"2024-10-29T17:14:15.659Z","etag":null,"topics":["kubernetes","nodejs"],"latest_commit_sha":null,"homepage":"","language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/gajus.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null},"funding":{"github":"gajus","patreon":"gajus"}},"created_at":"2018-06-30T15:02:55.000Z","updated_at":"2024-10-16T15:48:14.000Z","dependencies_parsed_at":"2024-06-18T12:41:11.539Z","dependency_job_id":"3a15a2f4-102c-44fa-9db5-2a00aa6ed079","html_url":"https://github.com/gajus/lightship","commit_stats":{"total_commits":158,"total_committers":10,"mean_commits":15.8,"dds":0.08860759493670889,"last_synced_commit":"0a57cc6d128f898c55a4877face8fadb50b89422"},"previous_names":[],"tags_count":68,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/gajus%2Flightship","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/gajus%2Flightship/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/gajus%2Flightship/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/gajus%2Flightship/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/gajus","download_url":"https://codeload.github.com/gajus/lightship/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247730069,"owners_count":20986404,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["kubernetes","nodejs"],"created_at":"2024-07-31T14:01:00.699Z","updated_at":"2025-04-07T21:15:37.814Z","avatar_url":"https://github.com/gajus.png","language":"TypeScript","funding_links":["https://github.com/sponsors/gajus","https://patreon.com/gajus"],"categories":["TypeScript","JavaScript"],"sub_categories":[],"readme":"# Lightship 🚢\n\n[![Coveralls](https://img.shields.io/coveralls/gajus/lightship.svg?style=flat-square)](https://coveralls.io/github/gajus/lightship)\n[![NPM version](http://img.shields.io/npm/v/lightship.svg?style=flat-square)](https://www.npmjs.org/package/lightship)\n[![Canonical Code Style](https://img.shields.io/badge/code%20style-canonical-blue.svg?style=flat-square)](https://github.com/gajus/canonical)\n[![Twitter Follow](https://img.shields.io/twitter/follow/kuizinas.svg?style=social\u0026label=Follow)](https://twitter.com/kuizinas)\n\n(Please read [Best practices](#best-practices) section.)\n\nAbstracts readiness, liveness and startup checks and graceful shutdown of Node.js services running in Kubernetes.\n\n{\"gitdown\": \"contents\"}\n\n## Behaviour\n\nCreates a HTTP service used to check [container probes](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes).\n\nRefer to the following Kubernetes documentation for information about the readiness and liveness checks:\n\n* [Pod Lifecycle](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/)\n* [Configure Liveness and Readiness Probes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/)\n\n### Local-mode\n\nIf Lightship detects that it is running in a non-Kubernetes environment (e.g. your local machine) then...\n\n* It starts the HTTP service on any available HTTP port. This is done to avoid port collision when multiple services using Lightship are being developed on the same machine.\n* `shutdownDelay` defaults to `0`, i.e. immediately proceed to execute the shutdown routine.\n\nDetection of the local-mode can be overridden by setting `{detectKubernetes: false}`.\n\n### `/health`\n\n`/health` endpoint describes the current state of a Node.js service.\n\nThe endpoint responds:\n\n* `200` status code, message \"SERVER_IS_READY\" when server is accepting new connections.\n* `500` status code, message \"SERVER_IS_NOT_READY\" when server is initialising.\n* `500` status code, message \"SERVER_IS_SHUTTING_DOWN\" when server is shutting down.\n\nUsed for human inspection.\n\n### `/live`\n\nThe endpoint responds:\n\n* `200` status code, message \"SERVER_IS_NOT_SHUTTING_DOWN\".\n* `500` status code, message \"SERVER_IS_SHUTTING_DOWN\".\n\nUsed to configure liveness probe.\n\n### `/ready`\n\nThe endpoint responds:\n\n* `200` status code, message \"SERVER_IS_READY\".\n* `500` status code, message \"SERVER_IS_NOT_READY\".\n\nUsed to configure readiness probe.\n\n### Timeouts\n\nLightship has two timeout configurations: `gracefulShutdownTimeout` and `shutdownHandlerTimeout`.\n\n`gracefulShutdownTimeout` (default: 30 seconds) is a number of milliseconds Lightship waits for Node.js process to exit gracefully after it receives a shutdown signal (either via `process` or by calling `lightship.shutdown()`) before killing the process using `process.exit(1)`. This timeout should be sufficiently big to allow Node.js process to complete tasks (if any) that are active at the time that the shutdown signal is received (e.g. complete serving responses to all HTTP requests) (Note: You must explicitly inform Lightship about active tasks using [beacons](#beacons)).\n\n`shutdownHandlerTimeout` (default: 5 seconds) is a number of milliseconds Lightship waits for shutdown handlers (see `registerShutdownHandler`) to complete before killing the process using `process.exit(1)`.\n\nIf after all beacons are dead and all shutdown handlers are resolved Node.js process does not exit gracefully, then Lightship will force terminate the process with an error. Refer to [How to detect what is holding the Node.js process alive?](#lightship-faq-how-to-detect-what-is-holding-the-node-js-process-alive).\n\n## Usage\n\nUse `createLightship` to create an instance of Lightship.\n\n```js\nimport {\n  createLightship\n} from 'lightship';\n\nconst configuration: ConfigurationInput = {};\n\nconst lightship: Lightship = await createLightship(configuration);\n\n```\n\nThe following types describe the configuration shape and the resulting Lightship instance interface.\n\n```js\n/**\n * A teardown function called when shutdown is initialized.\n */\ntype ShutdownHandler = () =\u003e Promise\u003cvoid\u003e | void;\n\n/**\n * @property detectKubernetes Run Lightship in local mode when Kubernetes is not detected. Default: true.\n * @property gracefulShutdownTimeout A number of milliseconds before forcefull termination if process does not gracefully exit. The timer starts when `lightship.shutdown()` is called. This includes the time allowed to live beacons. Default: 30000.\n * @property port The port on which the Lightship service listens. This port must be different than your main service port, if any. The default port is 9000. The default can be overwritten using LIGHTSHIP_PORT environment variable.\n * @property shutdownDelay Delays the shutdown handler by X milliseconds. This value should match `readinessProbe.periodSeconds`. Default 5000.\n * @property shutdownHandlerTimeout A number of milliseconds before forcefull termination if shutdown handlers do not complete. The timer starts when the first shutdown handler is called. Default: 5000.\n * @property signals An a array of [signal events]{@link https://nodejs.org/api/process.html#process_signal_events}. Default: [SIGTERM].\n * @property terminate Method used to terminate Node.js process. Default: `() =\u003e { process.exit(1) };`.\n */\nexport type ConfigurationInput = {|\n  +detectKubernetes?: boolean,\n  +gracefulShutdownTimeout?: number,\n  +port?: number,\n  +shutdownDelay?: number,\n  +shutdownHandlerTimeout?: number,\n  +signals?: $ReadOnlyArray\u003cstring\u003e,\n  +terminate?: () =\u003e void,\n|};\n\n/**\n * @property queueBlockingTask Forces service state to SERVER_IS_NOT_READY until all promises are resolved.\n * @property registerShutdownHandler Registers teardown functions that are called when shutdown is initialized. All registered shutdown handlers are executed in the order they have been registered. After all shutdown handlers have been executed, Lightship asks `process.exit()` to terminate the process synchronously.\n * @property shutdown Changes server state to SERVER_IS_SHUTTING_DOWN and initialises the shutdown of the application.\n * @property signalNotReady Changes server state to SERVER_IS_NOT_READY.\n * @property signalReady Changes server state to SERVER_IS_READY.\n * @property whenFirstReady Resolves the first time the service goes from `SERVER_IS_NOT_READY` to `SERVER_IS_READY` state.\n */\ntype Lightship = {|\n  +createBeacon: (context?: BeaconContext) =\u003e BeaconController,\n  +isServerReady: () =\u003e boolean,\n  +isServerShuttingDown: () =\u003e boolean,\n  +queueBlockingTask: (blockingTask: Promise\u003cany\u003e) =\u003e void,\n  +registerShutdownHandler: (shutdownHandler: ShutdownHandler) =\u003e void,\n  +server: http$Server,\n  +shutdown: () =\u003e Promise\u003cvoid\u003e,\n  +signalNotReady: () =\u003e void,\n  +signalReady: () =\u003e void,\n  +whenFirstReady: () =\u003e Promise\u003cvoid\u003e,\n|};\n\n```\n\n### Kubernetes container probe configuration\n\nThis is an example of a reasonable [container probe](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes) configuration to use with Lightship.\n\n```yaml\nreadinessProbe:\n  httpGet:\n    path: /ready\n    port: 9000\n  failureThreshold: 1\n  initialDelaySeconds: 5\n  periodSeconds: 5\n  successThreshold: 1\n  timeoutSeconds: 5\nlivenessProbe:\n  httpGet:\n    path: /live\n    port: 9000\n  failureThreshold: 3\n  initialDelaySeconds: 10\n  # Allow sufficient amount of time (90 seconds = periodSeconds * failureThreshold)\n  # for the registered shutdown handlers to run to completion.\n  periodSeconds: 30\n  successThreshold: 1\n  # Setting a very low timeout value (e.g. 1 second) can cause false-positive\n  # checks and service interruption.\n  timeoutSeconds: 5\n\n# As per Kubernetes documentation (https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#when-should-you-use-a-startup-probe),\n# startup probe should point to the same endpoint as the liveness probe.\n#\n# Startup probe is only needed when container is taking longer to start than\n# `initialDelaySeconds + failureThreshold × periodSeconds` of the liveness probe.\nstartupProbe:\n  httpGet:\n    path: /live\n    port: 9000\n  failureThreshold: 3\n  initialDelaySeconds: 10\n  periodSeconds: 30\n  successThreshold: 1\n  timeoutSeconds: 5\n\n```\n\n### Logging\n\n`lightship` is using [Roarr](https://github.com/gajus/roarr) to implement logging.\n\nSet `ROARR_LOG=true` environment variable to enable logging.\n\n### Queueing service blocking tasks\n\nYour service may not be ready until some asynchronous operation is complete, e.g. waiting for [`webpack-dev-middleware#waitUntilValid`](https://github.com/webpack/webpack-dev-middleware#waituntilvalidcallback). In this case, use `queueBlockingTask` to queue blocking tasks. This way, Lightship status will be set to `SERVER_IS_NOT_READY` until all blocking tasks are resolved (and `signalReady` has been called).\n\n```js\nimport express from 'express';\nimport {\n  createLightship\n} from 'lightship';\n\nconst lightship = await createLightship();\n\nlightship.queueBlockingTask(new Promise((resolve) =\u003e {\n  setTimeout(() =\u003e {\n    // Lightship service status will be `SERVER_IS_NOT_READY` until all promises\n    // submitted to `queueBlockingTask` are resolved.\n    resolve();\n  }, 1000);\n}));\n\nconst app = express();\n\napp.get('/', (req, res) =\u003e {\n  res.send('Hello, World!');\n});\n\nconst server = app.listen(8080, () =\u003e {\n  // All signals will be queued until after all blocking tasks are resolved.\n  lightship.signalReady();\n});\n\n```\n\n### Waiting for the server to become ready\n\n`whenFirstReady` can be used to wait until the first time the service becomes ready.\n\nThe promise returned by `whenFirstReady` is resolved only once. Use this function to delay execution of tasks that depend on the server to be ready.\n\n```js\nimport express from 'express';\nimport {\n  createLightship\n} from 'lightship';\n\nconst lightship = await createLightship();\n\nconst app = express();\n\napp.get('/', (req, res) =\u003e {\n  res.send('Hello, World!');\n});\n\nconst server = app.listen(8080, () =\u003e {\n  lightship.signalReady();\n});\n\n(async () =\u003e {\n  // `whenFirstReady` returns a promise that is resolved the first time that\n  // the service goes from `SERVER_IS_NOT_READY` to `SERVER_IS_READY` state.\n  await lightship.whenFirstReady();\n\n  await runIntegrationTests();\n})();\n\n```\n\n## Usage examples\n\n### Using with Express.js\n\nSuppose that you have Express.js application that simply respond \"Hello, World!\".\n\n```js\nimport express from 'express';\n\nconst app = express();\n\napp.get('/', (req, res) =\u003e {\n  res.send('Hello, World!');\n});\n\napp.listen(8080);\n\n```\n\nTo create a liveness and readiness check, simply create an instance of Lightship and use `registerShutdownHandler` to register a server shutdown handler, e.g.\n\n```js\nimport express from 'express';\nimport {\n  createLightship\n} from 'lightship';\n\nconst app = express();\n\napp.get('/', (req, res) =\u003e {\n  res.send('Hello, World!');\n});\n\nconst server = app\n  .listen(8080, () =\u003e {\n    // Lightship default state is \"SERVER_IS_NOT_READY\". Therefore, you must signal\n    // that the server is now ready to accept connections.\n    lightship.signalReady();\n  })\n  .on('error', () =\u003e {\n    lightship.shutdown();\n  });;\n\nconst lightship = await createLightship();\n\nlightship.registerShutdownHandler(() =\u003e {\n  server.close();\n});\n\n```\n\nSuppose that a requirement has been added that you need to ensure that you do not say \"Hello, World!\" more often than 100 times per minute.\n\nUse `signalNotReady` method to change server state to \"SERVER_IS_NOT_READY\" and use `signalReady` to revert the server state to \"SERVER_IS_READY\".\n\n```js\nimport express from 'express';\nimport {\n  createLightship\n} from 'lightship';\n\nconst app = express();\n\nconst minute = 60 * 1000;\n\nlet runningTotal = 0;\n\napp.get('/', (req, res) =\u003e {\n  runningTotal++;\n\n  setTimeout(() =\u003e {\n    runningTotal--;\n\n    if (runningTotal \u003c 100) {\n      lightship.signalReady();\n    } else {\n      lightship.signalNotReady();\n    }\n  }, minute);\n\n  res.send('Hello, World!');\n});\n\nconst server = app.listen(8080);\n\nconst lightship = await createLightship();\n\nlightship.registerShutdownHandler(() =\u003e {\n  server.close();\n});\n\n// Lightship default state is \"SERVER_IS_NOT_READY\". Therefore, you must signal\n// that the server is now ready to accept connections.\nlightship.signalReady();\n\n```\n\nHow quick Kubernetes observes that the server state has changed depends on the [probe configuration](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/#configure-probes), specifically `periodSeconds`, `successThreshold`\n and `failureThreshold`, i.e. expect requests to continue coming through for a while after the server state has changed.\n\nSuppose that a requirement has been added that the server must shutdown after saying \"Hello, World!\" 1000 times.\n\nUse `shutdown` method to change server state to \"SERVER_IS_SHUTTING_DOWN\", e.g.\n\n```js\nimport express from 'express';\nimport delay from 'delay';\nimport {\n  createLightship\n} from 'lightship';\n\nconst app = express();\n\nconst minute = 60 * 1000;\n\nlet total = 0;\nlet runningTotal = 0;\n\napp.get('/', (req, res) =\u003e {\n  total++;\n  runningTotal++;\n\n  if (total === 1000) {\n    lightship.shutdown();\n  }\n\n  setTimeout(() =\u003e {\n    runningTotal--;\n\n    if (runningTotal \u003c 100) {\n      lightship.signalReady();\n    } else {\n      lightship.signalNotReady();\n    }\n  }, minute);\n\n  res.send('Hello, World!');\n});\n\nconst server = app.listen(8080);\n\nconst lightship = await createLightship();\n\nlightship.registerShutdownHandler(async () =\u003e {\n  // Allow sufficient amount of time to allow all of the existing\n  // HTTP requests to finish before terminating the service.\n  await delay(minute);\n\n  server.close();\n});\n\n// Lightship default state is \"SERVER_IS_NOT_READY\". Therefore, you must signal\n// that the server is now ready to accept connections.\nlightship.signalReady();\n\n```\n\nDo not call `process.exit()` in a shutdown handler – Lighthouse calls `process.exit()` after all registered shutdown handlers have run to completion.\n\nIf for whatever reason a registered shutdown handler hangs, then (subject to the Pod's [restart policy](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy)) Kubernetes will forcefully restart the Container after the `livenessProbe` deems the service to be failed.\n\n### Beacons\n\nBeacons are used to delay the registered shutdown handler routine.\n\nA beacon can be created using `createBeacon()` method, e.g.\n\n```js\nconst lightship = await createLightship();\n\nconst beacon = lightship.createBeacon();\n\n```\n\nBeacon is live upon creation. Shutdown handlers are suspended until there are no live beacons.\n\nTo signal that a beacon is dead, use `die()` method:\n\n```js\nbeacon.die();\n// This beacon is now dead.\n\n```\n\nAfter beacon has been killed, it cannot be revived again.\n\nUse beacons to suspend the registered shutdown handler routine when you are processing a job queue, e.g.\n\n```js\nfor (const job of jobs) {\n  if (lightship.isServerShuttingDown()) {\n    log.info('detected that the service is shutting down; terminating the event loop');\n\n    break;\n  }\n\n  const beacon = lightship.createBeacon();\n\n  // Do the job.\n\n  await beacon.die();\n}\n\n```\n\nAdditionally, you can provide beacons with context, e.g.\n\n```js\nfor (const job of jobs) {\n  if (lightship.isServerShuttingDown()) {\n    log.info('detected that the service is shutting down; terminating the event loop');\n\n    break;\n  }\n\n  const beacon = lightship.createBeacon({\n    jobId: job.id\n  });\n\n  // Do the job.\n\n  await beacon.die();\n}\n\n```\n\nThe logs will include messages describing the beacons that are holding the connection, e.g.\n\n```json\n{\"context\":{\"package\":\"lightship\",\"namespace\":\"factories/createLightship\",\"logLevel\":30,\"beacons\":[{\"context\":{\"id\":1}}]},\"message\":\"program termination is on hold because there are live beacons\",\"sequence\":2,\"time\":1563892493825,\"version\":\"1.0.0\"}\n\n```\n\n## Best practices\n\n### Add a delay before stop handling incoming requests\n\nIt is important that you do not cease to handle new incoming requests immediatelly after receiving the shutdown signal. This is because there is a high probability of the SIGTERM signal being sent well before the iptables rules are updated on all nodes. The result is that the pod may still receive client requests after it has received the termination signal. If the app stops accepting connections immediately, it causes clients to receive \"connection refused\" types of errors.\n\nProperly shutting down an application includes these steps:\n\n1. Wait for a few seconds, then stop accepting new connections,\n2. Close all keep-alive connections that aren't in the middle of a request,\n3. Wait for all active requests to finish, and then\n4. Shut down completely.\n\nSee [Handling Client Requests Properly with Kubernetes](https://web.archive.org/web/20200807161820/https://freecontent.manning.com/handling-client-requests-properly-with-kubernetes/) for more information.\n\n## FAQ\n\n### What is the reason that my liveness/ readiness endpoints are intermittently failing?\n\nYou may discover that your service health checks are failing intermittently, e.g.\n\n```\nWarning  Unhealthy  4m17s (x3 over 4m27s)   kubelet, f95a4d94-jwfr  Liveness probe failed: Get http://10.24.7.155:9000/live: net/http: request canceled (Client.Timeout exceeded while awaiting headers)\nWarning  Unhealthy  3m28s (x15 over 4m38s)  kubelet, f95a4d94-jwfr  Readiness probe failed: Get http://10.24.7.155:9000/ready: net/http: request canceled (Client.Timeout exceeded while awaiting headers)\n\n```\n\nThis may happen if you are perfoming [event-loop blocking tasks](https://nodejs.org/ru/docs/guides/dont-block-the-event-loop/) for extended durations, e.g.\n\n```js\nconst startTime = Date.now();\n\nlet index0 = 1000;\n\nwhile (index0--) {\n  let index1 = 1000;\n\n  while (index1--) {\n    console.log(index0 + ':' + index1);\n  }\n}\n\nconsole.log(Date.now() - startTime);\n\n```\n\nIf executed, the above operation would block the event-loop for couple of seconds (e.g. 8 seconds on my machine). During this time Lightship is going to be unresponsive.\n\nYour options are:\n\n* Use [`worker_threads`](https://nodejs.org/api/worker_threads.html) to execute the event-loop blocking task in the background.\n* Refactor the code into [synchronous chunks](https://nodejs.org/ru/docs/guides/dont-block-the-event-loop/).\n\n### What is the reason for having separate `/live` and `/ready` endpoints?\n\nDistinct endpoints are needed if you want your Container to be able to take itself down for maintenance (as done in the [Using with Express.js](#lightship-usage-examples-using-with-express-js) usage example). Otherwise, you can use `/health`.\n\n### How to detect what is holding the Node.js process alive?\n\nYou may get a log message saying that your process did not exit on its own, e.g.\n\n```\n[2019-11-10T21:11:45.452Z] DEBUG (20) (@lightship) (#factories/createLightship): all shutdown handlers have run to completion; proceeding to terminate the Node.js process\n[2019-11-10T21:11:46.455Z] WARN (40) (@lightship) (#factories/createLightship): process did not exit on its own; investigate what is keeping the event loop active\n\n```\n\nThis means that there is some work that is scheduled to happen (e.g. a referenced `setTimeout`).\n\nIn order to understand what is keeping your Node.js process from exiting on its own, you need to identify all active handles and requests. This can be done with a help of utilities such as [`wtfnode`](https://www.npmjs.com/package/wtfnode) and [`why-is-node-running`](https://www.npmjs.com/package/why-is-node-running), e.g.\n\n```js\nimport whyIsNodeRunning from 'why-is-node-running';\nimport express from 'express';\nimport {\n  createLightship\n} from 'lightship';\n\nconst app = express();\n\napp.get('/', (req, res) =\u003e {\n  res.send('Hello, World!');\n});\n\nconst server = app.listen(8080);\n\nconst lightship = await createLightship();\n\nlightship.registerShutdownHandler(() =\u003e {\n  server.close();\n\n  whyIsNodeRunning();\n});\n\nlightship.signalReady();\n\n```\n\nIn the above example, calling `whyIsNodeRunning` will print a list of all active handles that are keeping the process alive.\n\n## Related projects\n\n* [Iapetus](https://github.com/gajus/iapetus) – Prometheus metrics server.\n* [Preoom](https://github.com/gajus/preoom) – Retrieves \u0026 observes Kubernetes Pod resource (CPU, memory) utilisation.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgajus%2Flightship","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fgajus%2Flightship","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgajus%2Flightship/lists"}