Steampipe Kubernetes Plugin

https://hub.steampipe.io/plugins/turbot/kubernetes
Admin
The Steampipe Kubernetes Plugin enables users to query Kubernetes cluster resources and manifest...
Tokens:61,712
Snippets:673
Trust Score:9.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Get Basic Kubernetes Endpoint Info (Steampipe CLI, Postgres, SQLite)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_endpoint

This example demonstrates how to retrieve the name, namespace, and subsets of active Kubernetes endpoints. It's useful for understanding the communication points within your clusters and for initial network troubleshooting. This query is compatible with Steampipe CLI, Postgres Foreign Data Wrapper, and SQLite Extension.

```sql
select
  name,
  namespace,
  subsets
from
  kubernetes_endpoint;
```

```sql
select
  name,
  namespace,
  subsets
from
  kubernetes_endpoint;
```

--------------------------------

### List All Kubernetes Certificates (SQL)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_%7Bcustom_resource_singular_name%7D

This SQL query lists all certificates present in the Kubernetes cluster, along with their name, UID, namespace, creation timestamp, and API version. It's useful for getting a comprehensive overview of certificate resources.

```sql
select
  name,
  uid,
  namespace,
  creation_timestamp,
  api_version
from
  kubernetes_certificate;
```

--------------------------------

### List Kubernetes Namespaces with Basic Info

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_namespace

Retrieve the name, status (phase), annotations, and labels for all Kubernetes namespaces. This query is useful for getting a quick overview of namespaces and their associated metadata.

```sql
select
  name,
  phase as status,
  annotations,
  labels
from
  kubernetes_namespace;
```

--------------------------------

### Steampipe Connection Configuration for Kubernetes

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_%7Bcustom_resource_singular_name%7D

This example shows a Steampipe connection configuration for the Kubernetes plugin. It specifies the plugin to use and configures custom resource tables to be included, such as 'certificates.*', enabling the querying of specific custom resource types.

```hcl
connection "kubernetes" {
  plugin = "kubernetes"
  custom_resource_tables = ["certificates.*"]
}

```

--------------------------------

### Install Kubernetes Plugin for Steampipe

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/mods

This command installs the Kubernetes plugin for Steampipe, allowing you to query Kubernetes resources using SQL. Ensure Steampipe is installed and configured before running this command.

```bash
steampipe plugin install kubernetes
```

--------------------------------

### Kubernetes Custom Resource Instance Example

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_%7Bcustom_resource_singular_name%7D

This snippet provides an example of a Kubernetes custom resource instance of type 'Certificate' from the cert-manager.io group. It shows a specific certificate resource named 'temporal-w-spcloud123456' with associated labels and specifications.

```yaml
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: temporal-w-spcloud123456
  labels:
    workspace-id: w_spcloud123456
    identity-id: o_spcloud123456
    region: apse1
    shard: "0001"
    workspace-pluginset: "202203170111114"
    app.kubernetes.io/component: steampipe-workspace-db
    app.kubernetes.io/managed-by: steampipe-api
    app.kubernetes.io/part-of: steampipe-cloud
    app.kubernetes.io/instance: w-spcloud123456
    app.kubernetes.io/version: 0.13.3-workspace-spcloud.20220317010004
spec:
  secretName: temporal-w-spcloud123456-tls
  duration: 87600h # 10 years
  dnsNames:
    - w-spcloud123456

```

--------------------------------

### Install Steampipe Kubernetes Plugin as SQLite Extension

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/index

Installs the Steampipe Kubernetes plugin as a SQLite Extension, making tables available as virtual tables. The installer script downloads and installs the appropriate package based on OS and system architecture. Configuration involves loading the extension module and running a configuration function.

```shell
/bin/sh -c "$(curl -fsSL https://steampipe.io/install/sqlite.sh)" -- kubernetes
```

```sqlite
$ sqlite3
sqlite> .load ./steampipe_sqlite_extension_kubernetes.so
sqlite> select steampipe_configure_kubernetes('<your_config>');
```

--------------------------------

### Kubernetes Custom Resource Definition (CRD) Example

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_%7Bcustom_resource_singular_name%7D

This snippet shows an example of a Kubernetes Custom Resource Definition (CRD) for certificates, specifically for the cert-manager.io group. It outlines the schema and structure for defining custom resources, including metadata, spec, and versions.

```yaml
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: certificates.cert-manager.io
  labels:
    app: cert-manager
    app.kubernetes.io/name: cert-manager-crd
spec:
  group: cert-manager.io
  names:
    kind: Certificate
    listKind: CertificateList
    plural: certificates
    shortNames:
      - cert
      - certs
    # table name - kubernetes_certificate
    singular: certificate
    categories:
      - cert-manager
  scope: Namespaced
  versions:
    - name: v1
      subresources:
        status: {}
      schema:
        openAPIV3Schema:
          description: "A Certificate resource should be created to ensure an up to date and signed x509 certificate is stored in the Kubernetes Secret resource named in `spec.secretName`."
          type: object
          required:
            - spec
          properties:
            apiVersion:
              description: The versioned schema of this representation of an object.
              type: string
            kind:
              description: A string value representing the REST resource this object represents.
              type: string
            metadata:
              type: object
            spec:
              description: Desired state of the Certificate resource.
              type: object
              required:
                - issuerRef
                - secretName
              properties:
                commonName:
                  description: A common name to be used on the Certificate.
                  type: string
                dnsNames:
                  description: A list of DNS subjectAltNames to be set on the Certificate.
                  type: array
                  items:
                    type: string
                duration:
                  description: "The requested 'duration' (i.e. lifetime) of the Certificate. Defaults to 90 days."
                  type: string
                ipAddresses:
                  description: A list of IP address subjectAltNames to be set on the Certificate.
                  type: array
                  items:
                    type: string
                isCA:
                  description: IsCA will mark this Certificate as valid for certificate signing.
                  type: boolean
                issuerRef:
                  description: A reference to the issuer for this certificate.
                  type: object
                  required:
                    - name
                  properties:
                    name:
                      description: Name of the resource being referred to.
                      type: string
                renewBefore:
                  description: "How long before the currently issued certificate's expiry cert-manager should renew the certificate. Default to 2/3 of the duration."
                  type: string
                secretName:
                  description: The name of the secret resource that will be automatically created and managed by this Certificate resource.
                  type: string
      served: true
      storage: true

```

--------------------------------

### Install Steampipe Kubernetes Plugin as Export CLI

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/index

Installs the Steampipe Kubernetes plugin as a standalone Export CLI, allowing data extraction without a database. The installer script downloads the appropriate tarball for the platform. Configuration is passed via the `--config` argument.

```shell
/bin/sh -c "$(curl -fsSL https://steampipe.io/install/export.sh)" -- kubernetes
```

```bash
steampipe_export_kubernetes --config '<your_config>' <table_name>
```

--------------------------------

### Query Custom Resources in Kubernetes

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_%7Bcustom_resource_singular_name%7D

This example demonstrates how to query custom Kubernetes resources using the Steampipe Kubernetes plugin. It shows how to access details of custom resources like certificates and capacity requests. If multiple custom resources share a singular name, the fully qualified name must be used.

```sql
SELECT
  *
FROM
  kubernetes_certificate
WHERE
  (
    name = 'temporal-w-spcloud123456'
  );
```

--------------------------------

### Exporting Kubernetes Data with Steampipe

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_value

Instructions on how to install and use the Steampipe exporter CLI to extract data using the Turbot Kubernetes plugin.

```APIDOC
## Export Kubernetes Data using Steampipe Exporter CLI

### Description
This section describes how to install and use the Steampipe exporter CLI to extract data from the Turbot Kubernetes plugin.

### Installation
Install the exporter with the `steampipe_export_installer.sh` script:

```bash
/bin/sh -c "$(curl -fsSL https://steampipe.io/install/export.sh)" -- kubernetes
```

### Usage
Pass configuration to the command with the `--config` argument:

```bash
steampipe_export_kubernetes --config '<your_config>' helm_value
```
```

--------------------------------

### Get Kubernetes Deployment Basic Info (PostgreSQL FDW / SQLite Extension)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_deployment

Retrieves basic information about Kubernetes deployments, calculating the age in seconds. This query is useful for monitoring the status and availability of applications.

```sql
select
  name,
  namespace,
  status_replicas,
  ready_replicas,
  updated_replicas,
  available_replicas,
  unavailable_replicas,
  (julianday('now') - julianday(creation_timestamp)) * 86400.0
from
  kubernetes_deployment
order by
  namespace,
  name;
```

--------------------------------

### List Active Kubernetes Jobs using SQL

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_job

Identify and list all currently active Kubernetes Jobs, displaying their name, namespace, start time, duration, and current status. This is useful for resource management and identifying potential bottlenecks.

```sql
select
  name,
  namespace,
  start_time,
  age(coalesce(completion_time, current_timestamp), start_time) as duration,
  active,
  succeeded,
  failed
from
  kubernetes_job
where active > 0;
```

```sql
select
  name,
  namespace,
  start_time,
  strftime('%s', coalesce(completion_time, current_timestamp)) - strftime('%s', start_time) as duration,
  active,
  succeeded,
  failed
from
  kubernetes_job
where active > 0;
```

--------------------------------

### Configure Kubernetes Connection in Steampipe

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/index

Example Steampipe configuration file for connecting to a Kubernetes cluster. It specifies the plugin, kubeconfig path, and context. The `source_types` argument determines what data the plugin will query.

```hcl
connection "kubernetes" {
  plugin         = "kubernetes"
  config_path    = "~/.kube/config"
  config_context = "myCluster"
  source_types   = ["deployed"]
}
```

--------------------------------

### Get Kubernetes Service Basic Info

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_service

Retrieves basic information about Kubernetes services across all namespaces, including name, namespace, type, cluster IP, and age. This query is useful for understanding the distribution and longevity of services within a cluster. It is compatible with Steampipe CLI, Postgres Foreign Data Wrapper, and SQLite Extension.

```sql
select
  name,
  namespace,
  type,
  cluster_ip,
  age(current_timestamp, creation_timestamp)
from
  kubernetes_service
order by
  namespace,
  name;
```

```sql
select
  name,
  namespace,
  type,
  cluster_ip,
  strftime('%s', 'now') - strftime('%s', creation_timestamp) as age
from
  kubernetes_service
order by
  namespace,
  name;
```

--------------------------------

### Get Basic Kubernetes Node Information

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_node

Retrieve fundamental details about Kubernetes nodes, such as their name, pod CIDRs, provider ID, creation timestamp, addresses, and capacity. This is useful for understanding the basic infrastructure and for efficient resource allocation.

```PostgreSQL
select
  name,
  pod_cidr,
  pod_cidrs,
  provider_id,
  creation_timestamp,
  addresses,
  capacity
from
  kubernetes_node;
```

```SQLite
select
  name,
  pod_cidr,
  pod_cidrs,
  provider_id,
  creation_timestamp,
  addresses,
  capacity
from
  kubernetes_node;
```

--------------------------------

### List Failed Kubernetes Jobs using SQL

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_job

Filter and display Kubernetes Jobs that have failed, showing their name, namespace, start time, duration, and failure count. This query aids in quickly detecting and troubleshooting job failures.

```sql
select
  name,
  namespace,
  start_time,
  age(coalesce(completion_time, current_timestamp), start_time) as duration,
  active,
  succeeded,
  failed
from
  kubernetes_job
where failed > 0;
```

```sql
select
  name,
  namespace,
  start_time,
  coalesce(completion_time, datetime('now')) - start_time as duration,
  active,
  succeeded,
  failed
from
  kubernetes_job
where failed > 0;
```

--------------------------------

### Get Role Bindings for Each Role (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_role_binding

This query groups role bindings by the role they reference and aggregates the names of the bindings for each role. It provides a summary of which role bindings are associated with each distinct role. Useful for understanding role usage across the cluster.

```sql
select
  role_name,
  jsonb_agg(name) as bindings
from
  kubernetes_role_binding
group by
  role_name;
```

--------------------------------

### Get Role Bindings for Each Role (PostgreSQL/SQLite)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_role_binding

This query groups role bindings by the role they reference and aggregates the names of the bindings for each role using JSON aggregation. It provides a summary of which role bindings are associated with each distinct role. Useful for understanding role usage across the cluster.

```sql
select
  role_name,
  json_group_array(name) as bindings
from
  kubernetes_role_binding
group by
  role_name;
```

--------------------------------

### Get Kubernetes Endpoint IP Information (Steampipe CLI, Postgres)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_endpoint

This example retrieves detailed endpoint IP information, including the IP address, readiness status, and protocol. It helps in network troubleshooting and enhancing security measures by identifying how endpoints are being used. This query is compatible with Steampipe CLI and Postgres Foreign Data Wrapper.

```sql
select
  name,
  namespace,
  addr ->> 'ip' as address,
  nr_addr ->> 'ip'  as not_ready_address,
  port -> 'port' as port,
  port ->> 'protocol' as protocol
from
  kubernetes_endpoint,
  jsonb_array_elements(subsets) as subset
  left join jsonb_array_elements(subset -> 'addresses') as addr on true
  left join jsonb_array_elements(subset -> 'notReadyAddresses') as nr_addr on true
  left join jsonb_array_elements(subset -> 'ports') as port on true;
```

```sql
select
  kubernetes_endpoint.name,
  kubernetes_endpoint.namespace,
  json_extract(addr.value, '$.ip') as address,
  json_extract(nr_addr.value, '$.ip') as not_ready_address,
  json_extract(port.value, '$.port') as port,
  json_extract(port.value, '$.protocol') as protocol
from
  kubernetes_endpoint,
  json_each(kubernetes_endpoint.subsets) as subset,
  json_each(json_extract(subset.value, '$.addresses')) as addr,
  json_each(json_extract(subset.value, '$.notReadyAddresses')) as nr_addr,
  json_each(json_extract(subset.value, '$.ports')) as port;
```

--------------------------------

### Query Basic DaemonSet Info (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_daemonset

Retrieves basic information about Kubernetes DaemonSets, including name, namespace, desired/current/ready/available pod counts, selector, and age. This query is suitable for the Steampipe CLI.

```sql
select
  name,
  namespace,
  desired_number_scheduled as desired,
  current_number_scheduled as current,
  number_ready as ready,
  number_available as available,
  selector,
  age(current_timestamp, creation_timestamp)
from
  kubernetes_daemonset;
```

--------------------------------

### Query Basic DaemonSet Info (Postgres FDG / SQLite Extension)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_daemonset

Retrieves basic information about Kubernetes DaemonSets, including name, namespace, desired/current/ready/available pod counts, selector, and age. This query is formatted for Postgres Foreign Data Gateway or SQLite Extension.

```sql
select
  name,
  namespace,
  desired_number_scheduled as desired,
  current_number_scheduled as current,
  number_ready as ready,
  number_available as available,
  selector,
  strftime('%s', 'now') - strftime('%s', creation_timestamp) as age
from
  kubernetes_daemonset;
```

--------------------------------

### Install Steampipe Kubernetes Plugin as Postgres FDW

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/index

Installs the Steampipe Kubernetes plugin as a native Postgres Foreign Data Wrapper (FDW). The script downloads and installs the appropriate files for the OS, system architecture, and Postgres version. It requires configuration of an extension, foreign server, and schema.

```shell
/bin/sh -c "$(curl -fsSL https://steampipe.io/install/postgres.sh)" -- kubernetes
```

```sql
CREATE EXTENSION IF NOT EXISTS steampipe_postgres_kubernetes;
CREATE SERVER steampipe_kubernetes FOREIGN DATA WRAPPER steampipe_postgres_kubernetes OPTIONS (config '<your_config>');
CREATE SCHEMA kubernetes;
IMPORT FOREIGN SCHEMA kubernetes FROM SERVER steampipe_kubernetes INTO kubernetes;
```

--------------------------------

### Kubernetes Service Table Documentation

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_service

Provides details on querying the `kubernetes_service` table, including its purpose, usage, and available schema.

```APIDOC
## Table: kubernetes_service

### Description

Queries Kubernetes Services to expose applications running on a set of Pods. Services determine the set of Pods through a Label Selector and provide a policy for accessing them.

### Method

GET

### Endpoint

/websites/hub_steampipe_io_plugins_turbot_kubernetes/tables/kubernetes_service

### Parameters

#### Query Parameters

- **all_namespaces** (boolean) - Optional - If true, query across all namespaces.
- **namespace** (string) - Optional - Filter by specific namespace.

#### Request Body

This endpoint does not accept a request body.

### Request Example

```sql
-- Basic Info
SELECT name, namespace, type, cluster_ip, age(current_timestamp, creation_timestamp) AS age
FROM kubernetes_service
ORDER BY namespace, name;

-- List manifest resources
SELECT name, namespace, type, cluster_ip, path
FROM kubernetes_service
WHERE path IS NOT NULL
ORDER BY namespace, name;
```

### Response

#### Success Response (200)

Returns a list of Kubernetes Service objects matching the query.

- **name** (string) - The name of the service.
- **namespace** (string) - The namespace the service belongs to.
- **type** (string) - The type of the service (e.g., ClusterIP, NodePort, LoadBalancer).
- **cluster_ip** (string) - The cluster IP address assigned to the service.
- **creation_timestamp** (timestamp) - The timestamp when the service was created.
- **path** (string) - The path associated with the service (if applicable).

#### Response Example

```json
[
  {
    "name": "my-service",
    "namespace": "default",
    "type": "ClusterIP",
    "cluster_ip": "10.0.0.1",
    "creation_timestamp": "2023-10-27T10:00:00Z",
    "path": null
  }
]
```

### Schema

- **_ctx** (jsonb) - Steampipe context.
- **allocate_load_balancer_node_ports** (boolean) - Indicates if NodePorts are automatically allocated for LoadBalancer services.
- **annotations** (jsonb) - Unstructured key value map for metadata.
- **cluster_ip** (text) - IP address of the service.
- **cluster_ips** (jsonb) - List of IP addresses assigned to the service.
- **context_name** (text) - Kubectl config context name.
- **creation_timestamp** (timestamp with time zone) - Server time when the object was created.
- **deletion_grace_period_seconds** (bigint) - Seconds allowed for graceful termination.
- **finalizers** (jsonb) - List of finalizers associated with the resource.
- **labels** (jsonb) - Key-value pairs of labels.
- **load_balancer_ingress** (jsonb) - Ingress configuration for load balancers.
- **name** (text) - Name of the service.
- **namespace** (text) - Namespace of the service.
- **ports** (jsonb) - List of ports exposed by the service.
- **preserve_seconds_after_completion** (bigint) - Number of seconds to preserve the resource after completion.
- **priority_class_name** (text) - Name of the priority class.
- **selector** (jsonb) - Label selector for the targeted Pods.
- **session_affinity** (text) - Session affinity configuration.
- **session_affinity_config** (jsonb) - Configuration for session affinity.
- **type** (text) - Type of the service (e.g., ClusterIP, NodePort, LoadBalancer).
- **uid** (text) - Unique identifier of the service.
```

--------------------------------

### Install Steampipe Exporter CLI for Kubernetes

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_node

Installs the Steampipe Exporter CLI for Kubernetes using a shell script. This allows exporting Kubernetes node data without a database.

```shell
/bin/sh -c "$(curl -fsSL https://steampipe.io/install/export.sh)" -- kubernetes

```

--------------------------------

### Query Kubernetes ReplicaSet Basic Info (SQL)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_replicaset

Retrieves basic information about Kubernetes ReplicaSets, including name, namespace, desired replicas, ready replicas, available replicas, selector, fully labeled replicas, and age. This query is useful for assessing the health and stability of application deployments.

```sql
select
  name,
  namespace,
  replicas as desired,
  ready_replicas as ready,
  available_replicas as available,
  selector,
  fully_labeled_replicas,
  age(current_timestamp, creation_timestamp)
from
  kubernetes_replicaset;
```

```sql
select
  name,
  namespace,
  replicas as desired,
  ready_replicas as ready,
  available_replicas as available,
  selector,
  fully_labeled_replicas,
  strftime('%s', 'now') - strftime('%s', creation_timestamp) as age
from
  kubernetes_replicaset;
```

--------------------------------

### Install Steampipe Exporter CLI

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_template

Installs the Steampipe Exporter CLI for the Kubernetes plugin using a shell script. This enables exporting Kubernetes data to various formats without requiring a database connection.

```bash
/bin/sh -c "$(curl -fsSL https://steampipe.io/install/export.sh)" -- kubernetes
```

--------------------------------

### List Kubernetes Cluster Role Bindings

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_cluster_role_binding

This query lists basic details of Kubernetes cluster role bindings, including name, role name, role kind, subjects, and path. It filters for bindings with a non-null path and orders the results by name. Requires Steampipe and the Kubernetes plugin.

```sql
select
  name,
  role_name,
  role_kind,
  subjects,
  path
from
  kubernetes_cluster_role_binding
where
  path is not null
order by
  name;
```

--------------------------------

### Kubernetes Pod Status and Metrics (`kubectl get pods` equivalent)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_pod

Provides a comprehensive view of Kubernetes pods, similar to `kubectl get pods`. This query aggregates information such as running container count, total container count, pod age, restart count, IP address, and node name. It's useful for overall pod health monitoring and resource management.

```PostgreSQL
select
  namespace,
  name,
  phase,
  count(cs) filter (
    where
      cs -> 'state' -> 'running' is not null
  ) as running_container_count,
  jsonb_array_length(containers) as container_count,
  age(current_timestamp, creation_timestamp),
  COALESCE(sum((cs ->> 'restartCount') :: int), 0) as restarts,
  pod_ip,
  node_name
from
  kubernetes_pod
  left join jsonb_array_elements(container_statuses) as cs on true
group by
  namespace,
  name,
  phase,
  containers,
  creation_timestamp,
  pod_ip,
  node_name
 order by
  namespace,
  name;
```

```SQLite
select
  namespace,
  name,
  phase,
  (select count(*) from json_each(container_statuses) as cs where json_extract(cs.value, '$.state.running') is not null) as running_container_count,
  (select count(*) from json_each(containers)) as container_count,
  julianday('now') - julianday(creation_timestamp) as age,
  COALESCE((select sum(json_extract(cs.value, '$.restartCount')) from json_each(container_statuses) as cs), 0) as restarts,
  pod_ip,
  node_name
from
  kubernetes_pod
group by
  namespace,
  name,
  phase,
  containers,
  creation_timestamp,
  pod_ip,
  node_name
order by
  namespace,
  name;
```

--------------------------------

### Query Kubernetes Cluster Role Bindings - Basic Info (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_cluster_role_binding

Retrieves basic information about Kubernetes cluster role bindings, including name, role name, subjects, and creation timestamp. Useful for a general overview of bindings. Requires the Steampipe CLI.

```sql
select
  name,
  role_name,
  role_kind,
  jsonb_pretty(subjects) as subjects,
  creation_timestamp
from
  kubernetes_cluster_role_binding
order by
  name;
```

--------------------------------

### List Kubernetes DaemonSet Resources

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_daemonset

Queries the Kubernetes plugin to list DaemonSet resources, their desired and current scheduled counts, availability, and selectors. It filters for resources where the 'path' attribute is not null. This helps in assessing resource allocation and utilization within DaemonSets.

```sql
select
  name,
  namespace,
  desired_number_scheduled as desired,
  current_number_scheduled as current,
  number_available as available,
  selector,
  path
from
  kubernetes_daemonset
where
  path is not null;
```

--------------------------------

### Query Kubernetes Cluster Role Bindings - Basic Info (Postgres FDW/SQLite)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_cluster_role_binding

Retrieves basic information about Kubernetes cluster role bindings, including name, role name, subjects, and creation timestamp. Useful for a general overview of bindings. Compatible with Postgres Foreign Data Wrappers and SQLite.

```sql
select
  name,
  role_name,
  role_kind,
  subjects,
  creation_timestamp
from
  kubernetes_cluster_role_binding
order by
  name;
```

--------------------------------

### Get a specific release

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_release

Retrieves detailed information about a single, specific Helm release by its name, allowing for in-depth analysis of its status and configuration.

```APIDOC
## Get a specific release

### Description
Analyze the settings to understand the status and details of a specific software release deployed using Helm, a package manager for Kubernetes. This query can be useful in tracking software versions and deployment statuses, providing insights into the efficiency of software management processes.

### Method
GET

### Endpoint
/websites/hub_steampipe_io_plugins_turbot_kubernetes/helm_release

### Query Parameters
- **name** (text) - Required - The name of the specific Helm release to retrieve.

### Response
#### Success Response (200)
- **name** (text) - The name of the release.
- **namespace** (text) - The Kubernetes namespace of the release.
- **version** (text) - The version of the Helm chart.
- **status** (text) - The current status of the release.
- **last_deployed** (timestamp with time zone) - The time when the release was last deployed.
- **description** (text) - A human-friendly description about the release.

#### Response Example
```json
{
  "name": "brigade-github-app-1683552635",
  "namespace": "brigade",
  "version": "1.0.0",
  "status": "deployed",
  "last_deployed": "2023-05-10T12:00:00Z",
  "description": "Brigade GitHub App release"
}
```
```

--------------------------------

### Get DaemonSet Containers and Images (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_daemonset

Extracts container names and images used within Kubernetes DaemonSets. This query is formatted for the Steampipe CLI.

```sql
select
  name,
  namespace,
  c ->> 'name' as container_name,
  c ->> 'image' as image
from
  kubernetes_daemonset,
  jsonb_array_elements(template -> 'spec' -> 'containers') as c
order by
  namespace,
  name;
```

--------------------------------

### Get DaemonSet Update Strategy (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_daemonset

Retrieves the update strategy type and maximum unavailable pods setting for Kubernetes DaemonSets. This query is formatted for the Steampipe CLI.

```sql
select
  namespace,
  name,
  update_strategy -> 'maxUnavailable' as max_unavailable,
  update_strategy -> 'type' as type
from
  kubernetes_daemonset;
```

--------------------------------

### Query Kubernetes Role Bindings - Basic Info (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_role_binding

This query retrieves basic information about Kubernetes role bindings, including their name, namespace, the role they reference, and the subjects they apply to. It formats the subjects as pretty-printed JSON. Useful for a high-level overview of access control configurations.

```sql
select
  name,
  namespace,
  role_name,
  role_kind,
  jsonb_pretty(subjects) as subjects,
  creation_timestamp
from
  kubernetes_role_binding
order by
  name;
```

--------------------------------

### List Storage Classes With Immediate Volume Binding Mode

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_storage_class

Find storage classes that have the 'Immediate' volume binding mode enabled. This query is useful for understanding storage configurations that allow for immediate volume provisioning, which can be critical for certain workloads.

```sql
select
  name,
  allow_volume_expansion,
  provisioner,
  reclaim_policy,
  volume_binding_mode
from
  kubernetes_storage_class
where
  volume_binding_mode = 'Immediate';
```

```sql
select
  name,
  allow_volume_expansion,
  provisioner,
  reclaim_policy,
  volume_binding_mode
from
  kubernetes_storage_class
where
  volume_binding_mode = 'Immediate';
```

--------------------------------

### Export Kubernetes Job Data

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_job

Exports Kubernetes job data using the Steampipe Exporter CLI. Requires the exporter to be installed and accepts a configuration argument to specify the data source.

```bash
steampipe_export_kubernetes --config '<your_config>' kubernetes_job
```

--------------------------------

### List Kubernetes Cluster Role Bindings (with JSONB Pretty)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_cluster_role_binding

This query retrieves details of Kubernetes cluster role bindings, including name, role name, role kind, subjects (pretty-printed JSONB), and path. It filters for bindings with a non-null path and orders the results by name. Requires Steampipe and the Kubernetes plugin.

```sql
select
  name,
  role_name,
  role_kind,
  jsonb_pretty(subjects) as subjects,
  path
from
  kubernetes_cluster_role_binding
where
  path is not null
order by
  name;
```

--------------------------------

### Export Kubernetes Data with Steampipe Exporter CLI

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_value

Executes the Steampipe Exporter CLI for Kubernetes, passing a configuration string to specify the data to be exported. The example shows exporting 'helm_value'.

```bash
steampipe_export_kubernetes --config '<your_config>' helm_value
```

--------------------------------

### List Manifest Resources (Postgres)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_deployment

Discovers Kubernetes deployments and their allocated resources (replicas) within a specific namespace. This query helps in resource management and optimization. Requires the Kubernetes plugin for Steampipe.

```sql
select
  name,
  namespace,
  replicas,
  path
from
  kubernetes_deployment
where
  path is not null
order by
  namespace,
  name;
```

--------------------------------

### List Kubernetes Services with Manifest Paths

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_service

Analyzes the distribution of resources within a Kubernetes cluster by listing services that have associated manifest paths. This helps identify potential resource allocation inefficiencies and improve cluster efficiency. This query is compatible with Steampipe CLI, Postgres Foreign Data Wrapper, and SQLite Extension.

```sql
select
  name,
  namespace,
  type,
  cluster_ip,
  path
from
  kubernetes_service
where
  path is not null
order by
  namespace,
  name;
```

```sql
select
  name,
  namespace,
  type,
  cluster_ip,
  path
from
  kubernetes_service
where
  path is not null
order by
  namespace,
  name;
```

--------------------------------

### List Manifest Resources for Kubernetes Nodes (Postgres FD)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_node

Lists Kubernetes nodes that have a specified path defined, along with their CIDR, provider ID, addresses, capacity, and path. This query filters nodes where the 'path' column is not null.

```sql
select
  name,
  pod_cidr,
  pod_cidrs,
  provider_id,
  addresses,
  capacity,
  path
from
  kubernetes_node
where
  path is not null;

```

--------------------------------

### Query Kubernetes Role Bindings - Basic Info (PostgreSQL/SQLite)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_role_binding

This query retrieves basic information about Kubernetes role bindings, including their name, namespace, the role they reference, and the subjects they apply to. It returns subjects as a JSON array. Useful for a high-level overview of access control configurations.

```sql
select
  name,
  namespace,
  role_name,
  role_kind,
  subjects,
  creation_timestamp
from
  kubernetes_role_binding
order by
  name;
```

--------------------------------

### Export Kubernetes Pod Security Policy Data (CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_pod_security_policy

This command demonstrates how to use the installed Kubernetes exporter to extract data for the 'kubernetes_pod_security_policy' resource. It requires a configuration argument to specify how Steampipe should connect and operate.

```cli
steampipe_export_kubernetes --config '<your_config>' kubernetes_pod_security_policy
```

--------------------------------

### Query Namespaces Using Default Search Path

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/index

SQL query to select all namespaces, relying on Steampipe's default search path to resolve the connection. This is a simpler alternative when only one Kubernetes connection is configured or when the desired connection is set as the default.

```sql
select * from kubernetes_namespace;
```

--------------------------------

### Get Job Containers and Images (SQLite)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_job

Retrieves a list of container names and images associated with each Kubernetes job. It uses SQLite's JSON functions to parse container specifications from the job's template.

```sql
select
  name,
  namespace,
  json_group_array(json_extract(elems.value, '$.name')) as containers,
  json_group_array(json_extract(elems.value, '$.image')) as images
from
  kubernetes_job,
  json_each(template, '$.spec.containers') as elems
group by
  name,
  namespace;
```

--------------------------------

### Get Job Containers and Images (PostgreSQL)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_job

Retrieves a list of container names and images associated with each Kubernetes job. It utilizes PostgreSQL's JSONB functions to parse container specifications from the job's template.

```sql
select
  name,
  namespace,
  jsonb_agg(elems.value -> 'name') as containers,
  jsonb_agg(elems.value -> 'image') as images
from
  kubernetes_job,
  jsonb_array_elements(template -> 'spec' -> 'containers') as elems
group by
  name,
  namespace;
```

--------------------------------

### List Kubernetes Job Manifest Resources

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_job

Lists details of active Kubernetes jobs, including their status (active, succeeded, failed), completion status, parallelism, selector, labels, annotations, and path. Filters for jobs that have a defined path.

```sql
select
  name,
  namespace,
  active,
  succeeded,
  failed,
  completions,
  parallelism,
  selector,
  labels,
  annotations,
  path
from
  kubernetes_job
where
  path is not null;
```

--------------------------------

### Get Container Images Used in Kubernetes Deployments (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_deployment

Extracts container image information from Kubernetes deployments. This query is valuable for tracking image versions and ensuring consistency across your deployed applications.

```sql
select
  name as deployment_name,
  namespace,
  c ->> 'name' as container_name,
  c ->> 'image' as image
from
  kubernetes_deployment,
  jsonb_array_elements(template -> 'spec' -> 'containers') as c
order by
  namespace,
  name;
```

--------------------------------

### Get Kubernetes Deployment Configuration Info (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_deployment

Retrieves configuration details of Kubernetes deployments, such as paused status, generation, replica count, and strategy. This query helps understand the settings and state of deployments.

```sql
select
  name,
  paused,
  generate_name,
  generation,
  revision_history_limit,
  replicas,
  strategy,
  selector
from
  kubernetes_deployment;
```

--------------------------------

### List Kubernetes Endpoints with Specified Path (Steampipe CLI, Postgres, SQLite)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_endpoint

This example lists Kubernetes endpoints that have a specified path defined. It is useful for understanding the distribution of resources within your Kubernetes environment and for managing specific endpoint configurations. This query is compatible with Steampipe CLI, Postgres Foreign Data Wrapper, and SQLite Extension.

```sql
select
  name,
  namespace,
  subsets,
  path
from
  kubernetes_endpoint
where
  path is not null;
```

```sql
select
  name,
  namespace,
  subsets,
  path
from
  kubernetes_endpoint
where
  path is not null;
```

--------------------------------

### Get Kubernetes Deployment Basic Info (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_deployment

Retrieves basic information about Kubernetes deployments, including name, namespace, replica counts, and age. This query is useful for monitoring the status and availability of applications.

```sql
select
  name,
  namespace,
  status_replicas,
  ready_replicas,
  updated_replicas,
  available_replicas,
  unavailable_replicas,
  age(current_timestamp, creation_timestamp)
from
  kubernetes_deployment
order by
  namespace,
  name;
```

--------------------------------

### Get DaemonSet Containers and Images (Postgres FDG / SQLite Extension)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_daemonset

Extracts container names and images used within Kubernetes DaemonSets. This query is formatted for Postgres Foreign Data Gateway or SQLite Extension.

```sql
select
  name,
  namespace,
  json_extract(c.value, '$.name') as container_name,
  json_extract(c.value, '$.image') as image
from
  kubernetes_daemonset,
  json_each(json_extract(template, '$.spec.containers')) as c
order by
  namespace,
  name;
```

--------------------------------

### Query Kubernetes Job Details using SQL

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_job

Retrieve comprehensive information about Kubernetes Jobs, including their name, namespace, status, timings, and configuration. This query helps in monitoring job progress and performance.

```sql
select
  name,
  namespace,
  active,
  succeeded,
  failed,
  completions,
  start_time,
  completion_time,
  age(coalesce(completion_time, current_timestamp), start_time) as duration,
  active_deadline_seconds,
  parallelism,
  selector,
  labels,
  annotations
from
  kubernetes_job;
```

```sql
select
  name,
  namespace,
  active,
  succeeded,
  failed,
  completions,
  start_time,
  completion_time,
  strftime('%s', coalesce(completion_time, current_timestamp)) - strftime('%s', start_time) as duration,
  active_deadline_seconds,
  parallelism,
  selector,
  labels,
  annotations
from
  kubernetes_job;
```

--------------------------------

### Query Rendered Kubernetes Helm Templates for a Specific Environment

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_template_rendered

SQL query to list rendered Kubernetes resource templates for a specific environment defined in the Steampipe connection configuration. This example queries the 'my-app-dev' environment.

```sql
select
  chart_name,
  path,
  source_type,
  rendered
from
  helm_template_rendered
where
  source_type = 'helm_rendered:my-app-dev';
```

--------------------------------

### Get Cluster Role Bindings for Each Role (Steampipe CLI)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_cluster_role_binding

Aggregates and lists cluster role bindings by role name. This query is useful for identifying all bindings associated with a specific role. Requires the Steampipe CLI.

```sql
select
  role_name,
  jsonb_agg(name) as bindings
from
  kubernetes_cluster_role_binding
group by
  role_name;
```

--------------------------------

### List Kubernetes Namespaces with Manifest Path

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_namespace

Fetch namespaces that have a manifest path associated with them, along with their name, status, annotations, and labels. This helps in identifying namespaces managed by specific manifest files.

```sql
select
  name,
  phase as status,
  annotations,
  labels,
  path
from
  kubernetes_namespace
where
  path is not null;
```

--------------------------------

### Get Basic Kubernetes Cluster Role Info

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_cluster_role

Retrieves the name, creation timestamp, rules, and aggregation rule for all Kubernetes cluster roles. This query is useful for a high-level overview of cluster role configurations.

```sql
select
  name,
  creation_timestamp,
  rules,
  aggregation_rule
from
  kubernetes_cluster_role
order by
  name;
```

```sql
select
  name,
  creation_timestamp,
  rules,
  aggregation_rule
from
  kubernetes_cluster_role
order by
  name;
```

--------------------------------

### List Kubernetes Deployments by Helm Chart

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_release

SQL query to identify Kubernetes deployments managed by Helm, linked to a specific chart (e.g., 'ingress-nginx'). It joins `kubernetes_deployment` and `helm_release` tables based on labels and filters by chart name and deployment status.

```sql
select
  d.name as deployment_name,
  d.namespace,
  d.uid,
  r.name as release_name,
  r.chart_name,
  r.version as release_version,
  r.first_deployed as deployed_at
from
  kubernetes_deployment as d
  left join helm_release as r
    on (
      d.labels ->> 'app.kubernetes.io/managed-by' = 'Helm'
      and d.labels ->> 'app.kubernetes.io/instance' = r.name
    )
where
  r.chart_name = 'ingress-nginx'
  and d.source_type = 'deployed';
```

```sql
select
  d.name as deployment_name,
  d.namespace,
  d.uid,
  r.name as release_name,
  r.chart_name,
  r.version as release_version,
  r.first_deployed as deployed_at
from
  kubernetes_deployment as d
  left join helm_release as r
    on (
      json_extract(d.labels, '$.app.kubernetes.io/managed-by') = 'Helm'
      and json_extract(d.labels, '$.app.kubernetes.io/instance') = r.name
    )
where
  r.chart_name = 'ingress-nginx'
  and d.source_type = 'deployed';
```

--------------------------------

### Get basic Helm chart information

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_chart

Retrieves basic information about Helm charts, including name, API version, version, deprecation status, type, and description. This helps in identifying and managing Helm chart details.

```sql
select
  name,
  api_version,
  version,
  deprecated,
  type,
  description
from
  helm_chart;
```

--------------------------------

### Query Rendered Kubernetes Helm Templates by Chart

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/helm_template_rendered

SQL query to list fully rendered Kubernetes resource templates within a specific Helm chart. Useful for inspecting chart contents, for example, the 'redis' chart.

```sql
select
  path,
  source_type,
  rendered
from
  helm_template_rendered
where
  chart_name = 'redis';
```

--------------------------------

### List Kubernetes Certificates Added in Last 24 Hours (SQL)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_%7Bcustom_resource_singular_name%7D

This SQL query filters and retrieves certificates that have been created within the last 24 hours. It helps in tracking recent certificate additions and changes in the Kubernetes environment.

```sql
select
  name,
  uid,
  namespace,
  creation_timestamp,
  api_version
from
  kubernetes_certificate
where
  creation_timestamp = now() - interval '24 hrs';
```

--------------------------------

### List Kubernetes Endpoint Slices with Paths

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_endpoint_slice

Identifies Kubernetes Endpoint Slices that have a defined path. This query helps in understanding the distribution and configuration of resources within a Kubernetes cluster, which is crucial for efficient cluster management and troubleshooting.

```sql
select
  name,
  namespace,
  generate_name as endpoint_name,
  address_type,
  endpoints,
  ports,
  path
from
  kubernetes_endpoint_slice
where
  path is not null;
```

```postgres
select
  name,
  namespace,
  generate_name as endpoint_name,
  address_type,
  endpoints,
  ports,
  path
from
  kubernetes_endpoint_slice
where
  path is not null;
```

```sqlite
select
  name,
  namespace,
  generate_name as endpoint_name,
  address_type,
  endpoints,
  ports,
  path
from
  kubernetes_endpoint_slice
where
  path is not null;
```

--------------------------------

### Get Container Images Used in Kubernetes Deployments (PostgreSQL FDW / SQLite Extension)

Source: https://hub.steampipe.io/plugins/turbot/kubernetes/tables/kubernetes_deployment

Extracts container image information from Kubernetes deployments. This query is valuable for tracking image versions and ensuring consistency across your deployed applications.

```sql
select
  name as deployment_name,
  namespace,
  json_extract(c.value, '$.name') as container_name,
  json_extract(c.value, '$.image') as image
from
  kubernetes_deployment,
  json_each(json_extract(template, '$.spec.containers')) as c
order by
  namespace,
  name;
```
Tokens:
Raw