Jeffrey Regan 3a01a63a01 Simplify code base.
- In ResMap, drop concept of internal Id to Resource
   map.  The ResMap is now (just) a list, allowing only
   very particular edits.

 - Resources should now be maintained in the order
   loaded.  A later PR can adjust tests to remove the
   internal legacy sorting, and confirm order-out is
   predictable from order-in.  The PR would suppress
   the sort in tests, and reorder the output to make
   all tests pass again, and confirm that the new order
   matched depth-first input traversal.  The FromMap
   fixture function was removed from all test inputs to
   establish a predictable input order.

 - Resources now have two 'Ids', OriginalId and
   CurrentId.  The former is fixed as
   GVK-name-namespace at load time, the latter changes
   during transformations.  The latter can be used to
   narrow name references when the former maps to
   multiple resources.  We allow bases to be loaded
   more than once in a build (a diamond pattern), so
   the OriginalId is not unique across the resources
   set.  The CurrentId is (and must be) unique, but is
   constantly mutating.  Failing to make this
   distinction clear, and attempting to maintain a
   mapping from a single mutating Id to a resource was
   making the code too complex.

 - Drop prefix/suffix from ResId - the ResId is now
   immutable.  A later PR can remove the distinction
   with ItemId.

 - This PR increases coverage of ResMap is since this
   is a large refactor.  Higher level tests didn't need
   much change outside reordering of results at the
   resource level.
2019-06-17 10:50:45 -07:00
2019-05-29 11:21:40 -07:00
2019-06-11 19:37:06 -07:00
2019-05-27 15:37:03 -07:00
2019-06-17 10:50:45 -07:00
2019-06-17 10:50:45 -07:00
2019-06-17 10:50:45 -07:00
2019-05-30 10:10:16 -07:00
2019-06-12 20:33:07 -07:00
2019-06-11 12:52:53 -07:00
2019-06-11 12:52:53 -07:00
2019-03-17 13:39:48 -07:00
2018-05-08 10:37:01 -07:00
2018-05-11 11:33:39 -07:00
2019-01-14 14:06:02 -08:00

kustomize

kustomize lets you customize raw, template-free YAML files for multiple purposes, leaving the original YAML untouched and usable as is.

kustomize targets kubernetes; it understands and can patch kubernetes style API objects. It's like make, in that what it does is declared in a file, and it's like sed, in that it emits editted text.

This tool is sponsored by sig-cli (KEP), and inspired by DAM.

Build Status Go Report Card

Download a binary from the release page, or see these instructions.

Browse the docs or jump right into the tested examples.

kustomize v2.0.3 is available in kubectl v1.14.

Usage

1) Make a kustomization file

In some directory containing your YAML resource files (deployments, services, configmaps, etc.), create a kustomization file.

This file should declare those resources, and any customization to apply to them, e.g. add a common label.

base image

File structure:

~/someApp
├── deployment.yaml
├── kustomization.yaml
└── service.yaml

The resources in this directory could be a fork of someone else's configuration. If so, you can easily rebase from the source material to capture improvements, because you don't modify the resources directly.

Generate customized YAML with:

kustomize build ~/someApp

The YAML can be directly applied to a cluster:

kustomize build ~/someApp | kubectl apply -f -

2) Create variants using overlays

Manage traditional variants of a configuration - like development, staging and production - using overlays that modify a common base.

overlay image

File structure:

~/someApp
├── base
│   ├── deployment.yaml
│   ├── kustomization.yaml
│   └── service.yaml
└── overlays
    ├── development
    │   ├── cpu_count.yaml
    │   ├── kustomization.yaml
    │   └── replica_count.yaml
    └── production
        ├── cpu_count.yaml
        ├── kustomization.yaml
        └── replica_count.yaml

Take the work from step (1) above, move it into a someApp subdirectory called base, then place overlays in a sibling directory.

An overlay is just another kustomization, refering to the base, and referring to patches to apply to that base.

This arrangement makes it easy to manage your configuration with git. The base could have files from an upstream repository managed by someone else. The overlays could be in a repository you own. Arranging the repo clones as siblings on disk avoids the need for git submodules (though that works fine, if you are a submodule fan).

Generate YAML with

kustomize build ~/someApp/overlays/production

The YAML can be directly applied to a cluster:

kustomize build ~/someApp/overlays/production | kubectl apply -f -

Community

To file bugs please read this.

Before working on an implementation, please

Other communication channels

Code of conduct

Participation in the Kubernetes community is governed by the Kubernetes Code of Conduct.

Description
No description provided
Readme Apache-2.0 127 MiB
2026-02-09 16:15:02 +00:00
Languages
Go 58.2%
PureBasic 40.7%
Shell 0.6%
Makefile 0.3%
HTML 0.1%