Kubernetes

Kubernetes enables deployment, scaling, and management of containerized applications. GoLand provides support for Kubernetes resource configuration files via the Kubernetes plugin.

The Kubernetes plugin supports Kubernetes API starting from version 1.5. It provides rich support for resource configuration files in YAML, and only basic support for the JSON format.

Feature	YAML	JSON
Auto-completion	Supported	Supported
	Supported	Supported
Inspections and quick fixes	Invalid, missing, and duplicated keys Non-editable (read-only) keys and resources Deprecated keys and resources Invalid integer and enum key values	Invalid, missing, and duplicated properties
Live templates	Predefined templates for common configuration kinds: `kcm`: ConfigMap `kdep`: Deployment `kpod`: Pod `kres`: Generic resource `kser`: Service	No predefined live templates
Smart completion	Supported	Not supported
Custom resource definitions	Supported	Not supported
Label definitions and selectors	Navigation using gutter icons, find usages, and renaming	Not supported
Enhancements of the original Kubernetes model	Enums instead of plain strings where applicable	None

The Kubernetes plugin also adds support for path completion in Kustomize files and navigation between Kustomize files and patches. The list of related Kustomize files appears in the editor at the top of the open Kustomize patch.

You can use the Services tool window to see all resources of the Kubernetes cluster in the current context, jump to relevant resource definitions, and view logs for containers running on pods.

Resource configuration files

GoLand recognizes Kubernetes resource configuration files using the following mandatory fields:

apiVersion: identifies the versioned schema of the object representation
kind: identifies the object kind (for example, Service, Pod, Deployment, and so on)

If both of the previous fields are present in a YAML or JSON file, GoLand will mark the file with the corresponding Kubernetes icon and enable all available features:

For YAML files, you can also use predefined Live Templates to create the necessary type of configuration:

To see available Live Templates and create new ones, open the Settings/Preferences dialog Ctrl+Alt+S, click Editor, then click Live Templates, and expand the Kubernetes group in the list.

Helm support

Helm is a tool for managing Kubernetes applications. Helm charts are packages of pre-configured resource definitions that you run inside a Kubernetes cluster. A chart contains a description of the package Chart.yaml and one or more templates used to generate Kubernetes manifest files.

Coding assistance for Helm charts and templates includes code completion, refactorings, inspections, quick fixes, and quick documentation. Also, it is possible to use gutter icons for navigating between label definitions and label selectors, and between overridden and overriding values. Code completion includes values of dependencies from the specified repository (by default, from Helm Hub).

By default, Go template directives are rendered as the actual values in Helm templates. You can click the value to expand and show the directive. This functionality is implemented using code folding. Press Ctrl+NumPad Plus and Ctrl+NumPad - to toggle between values and directives.

Create a new Helm chart

Right-click any directory in the Project tool window, point to Kubernetes, and click Helm Create Chart.

This runs the helm create command, which adds all the basic files required to get started:

.helmignore: Patterns to ignore when building packages
Chart.yaml: A basic chart description with metadata
values.yaml: Default values for chart templates
charts/: Directory for sub-charts
templates/: Directory for chart definitions
- _helpers.tpl: Partials and functions for your templates
- NOTES.txt: Information that is printed out after a chart is deployed
- deployment.yaml: Example Kubernetes deployment definition
- ingress.yaml: Example Kubernetes ingress definition
- service.yaml: Example Kubernetes service definition

Preview the result of Helm template rendering

Right-click the template file, point to Kubernetes, and click Helm Template.

This runs the helm template command that renders a chart template. The rendered preview opens inside the diff viewer dialog to compare it with the original template file.

Update external dependencies

Right-click the chart, point to Kubernetes, and click Helm Dependency Update.

This runs the helm dependency update command.

In Helm 2, dependencies should be specified in the requirements.yaml file. This action also generates or updates requirements.lock.

In Helm 3, dependencies should be specified in the Chart.yaml file. If you specify the dependencies in the wrong file, GoLand provides an inspection with a quick-fix to move them.

Examine a chart for possible issues

Right-click the chart, point to Kubernetes, and click Helm Lint.

This runs the helm lint command that executes a series of tests to discover possible problems without actually installing the chart.

Custom resource definitions support

If your Kubernetes cluster is extended with custom resources, GoLand can validate them with custom resource definition (CRD) specifcations.

Specify the path to CRD specifications

In the Settings/Preferences dialog Ctrl+Alt+S, select Languages & Frameworks | Kubernetes.
Click and either select a local CRD file or specify a URL. Then click OK.

Use and to rearrange the list of CRD files. This defines the priority for conflicting definitions: the lowest one is used if it is defined in more than one file.

The Kubernetes plugin supports specifying the path to CRD files of the following types:

CustomResourceDefinition files in YAML

The following example shows a simple CustomResourceDefinition specification for a custom resource stable.example.com/v1 of the kind CronTab. Obligatory fields to identify the resource are metadata.name, spec.group, spec.versions, and spec.names.

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: crontabs.stable.example.com # Obligatory field to identify the resource
spec:
  group: stable.example.com # Obligatory field to identify the resource
  versions: # Obligatory field to identify the resource
    - name: v1
      served: true
      storage: true
  scope: Namespaced
  names: # Obligatory field to identify the resource
    plural: crontabs
    singular: crontab
    kind: CronTab
    shortNames:
      - ct
validation:
  openAPIV3Schema: # Schema for validating custom objects
    properties:
      spec:
        properties:
          cronSpec:
            type: string
            pattern: '^(\d+|\*)(/\d+)?(\s+(\d+|\*)(/\d+)?){4}$' # not supported for validation
          replicas:
            type: integer
            minimum: 1 # not supported for validation
            maximum: 10 # not supported for validation
            

OpenAPI v2.0 schema in JSON

The following example shows a simple OpenAPI v2.0 schema with a CRD specification for a custom resource sample/v1 of the kind Config. The root definition of the custom resource must contain the x-kubernetes-group-version-kind field with the specified group, version, and kind. In the example, the root.Definition object uses a build property to reference the some.Definition object.

{
    "swagger": "2.0",
    "info": {
        "title": "Sample Schema",
        "version": "sample/v1"
    },
    "paths": {},
    "definitions": {
        "some.Definition": {
            "description": "Example of a definition.",
            "properties": {
                "someProperty": {
                    "type": "string"
                }
            }
        },
        "root.Definition": {
            "description": "This is the root definition for the resource",
            "properties": {
                "build": {
                    "$ref": "#/definitions/some.Definition"
                }
            },
            "x-kubernetes-group-version-kind": [
                {
                    "group": "sample",
                    "kind": "Config",
                    "version": "v1"
                }
            ]
        }
    }
}
            

CRD validation restrictions

The following OpenAPI v3 schema features are not supported:

multipleOf
maximum
exclusiveMaximum
minimum
exclusiveMinimum
maxLength
minLength
pattern
maxItems
minItems
uniqueItems
maxProperties
minProperties
allOf
oneOf
anyOf
not
format
default
nullable
readOnly
writeOnly
xml
externalDocs
example
deprecated

Productivity tips

If you use the features described here frequently, the following tips may be helpful:

Assign shortcuts

You can assign a keyboard shortcut for Kubernetes actions.

In the Settings/Preferences dialog Ctrl+Alt+S, select Keymap.
Type kubernetes in the search field, then double-click an action to set a shortcut for it.

Alternatively, you can use the Find Action dialog Ctrl+Shift+A, type kubernetes, select the necessary action, and press Alt+Enter.

Configure code folding

By default, GoLand uses code folding to render value references in Helm templates and definitions in Kubernetes configuration files as the actual values. You can click the value to expand it or press Ctrl+NumPad Plus and Ctrl+NumPad - to toggle folding. If you want to see the references and defintions expanded by default, do the following:

In the Settings/Preferences dialog Ctrl+Alt+S, select Editor | General | Code Folding.
On the Code Folding page, clear the necessary checkboxes:
- Kubernetes: value references in Helm templates
- Kubernetes: EnvVar definitions in YAML files
- Kubernetes: ExecAction definitions in YAML files

Last modified: 23 March 2020