installer: github.com/openshift/installer/pkg/types Index | Files | Directories

package types

import "github.com/openshift/installer/pkg/types"

Package types defines structures for installer configuration and management.

Index

Package Files

clustermetadata.go doc.go installconfig.go machinepools.go

Constants

const (
    // ArchitectureAMD64 indicates AMD64 (x86_64).
    ArchitectureAMD64 = "amd64"
    // ArchitectureS390X indicates s390x (IBM System Z).
    ArchitectureS390X = "s390x"
    // ArchitecturePPC64LE indicates ppc64 little endian (Power PC)
    ArchitecturePPC64LE = "ppc64le"
)
const (
    // InstallConfigVersion is the version supported by this package.
    // If you bump this, you must also update the list of convertable values in
    // pkg/types/conversion/installconfig.go
    InstallConfigVersion = "v1"
)

Variables

var (
    // PlatformNames is a slice with all the visibly-supported
    // platform names in alphabetical order. This is the list of
    // platforms presented to the user in the interactive wizard.
    PlatformNames = []string{
        aws.Name,
        azure.Name,
        gcp.Name,
        openstack.Name,
        ovirt.Name,
        vsphere.Name,
    }
    // HiddenPlatformNames is a slice with all the
    // hidden-but-supported platform names. This list isn't presented
    // to the user in the interactive wizard.
    HiddenPlatformNames = []string{
        baremetal.Name,
        kubevirt.Name,
        none.Name,
    }
)

type Architecture Uses

type Architecture string

Architecture is the instruction set architecture for the machines in a pool. +kubebuilder:validation:Enum="";amd64

type ClusterMetadata Uses

type ClusterMetadata struct {
    // clusterName is the name for the cluster.
    ClusterName string `json:"clusterName"`
    // clusterID is a globally unique ID that is used to identify an Openshift cluster.
    ClusterID string `json:"clusterID"`
    // infraID is an ID that is used to identify cloud resources created by the installer.
    InfraID                 string `json:"infraID"`
    ClusterPlatformMetadata `json:",inline"`
}

ClusterMetadata contains information regarding the cluster that was created by installer.

type ClusterNetworkEntry Uses

type ClusterNetworkEntry struct {
    // CIDR is the IP block address pool.
    CIDR ipnet.IPNet `json:"cidr"`

    // HostPrefix is the prefix size to allocate to each node from the CIDR.
    // For example, 24 would allocate 2^8=256 adresses to each node. If this
    // field is not used by the plugin, it can be left unset.
    // +optional
    HostPrefix int32 `json:"hostPrefix,omitempty"`

    // The size of blocks to allocate from the larger pool.
    // This is the length in bits - so a 9 here will allocate a /23.
    // +optional
    DeprecatedHostSubnetLength int32 `json:"hostSubnetLength,omitempty"`
}

ClusterNetworkEntry is a single IP address block for pod IP blocks. IP blocks are allocated with size 2^HostSubnetLength.

type ClusterPlatformMetadata Uses

type ClusterPlatformMetadata struct {
    AWS       *aws.Metadata       `json:"aws,omitempty"`
    OpenStack *openstack.Metadata `json:"openstack,omitempty"`
    Libvirt   *libvirt.Metadata   `json:"libvirt,omitempty"`
    Azure     *azure.Metadata     `json:"azure,omitempty"`
    GCP       *gcp.Metadata       `json:"gcp,omitempty"`
    BareMetal *baremetal.Metadata `json:"baremetal,omitempty"`
    Ovirt     *ovirt.Metadata     `json:"ovirt,omitempty"`
    VSphere   *vsphere.Metadata   `json:"vsphere,omitempty"`
    Kubevirt  *kubevirt.Metadata  `json:"kubevirt,omitempty"`
}

ClusterPlatformMetadata contains metadata for platfrom.

func (*ClusterPlatformMetadata) Platform Uses

func (cpm *ClusterPlatformMetadata) Platform() string

Platform returns a string representation of the platform (e.g. "aws" if AWS is non-nil). It returns an empty string if no platform is configured.

type CredentialsMode Uses

type CredentialsMode string

CredentialsMode is the mode by which CredentialsRequests will be satisfied. +kubebuilder:validation:Enum="";Mint;Passthrough;Manual

const (
    // ManualCredentialsMode indicates that cloud-credential-operator should not process any CredentialsRequests.
    ManualCredentialsMode CredentialsMode = "Manual"

    // MintCredentialsMode indicates that cloud-credential-operator should be creating users for each
    // CredentialsRequest.
    MintCredentialsMode CredentialsMode = "Mint"

    // PassthroughCredentialsMode indicates that cloud-credential-operator should just copy over the cluster's
    // cloud credentials for each CredentialsRequest.
    PassthroughCredentialsMode CredentialsMode = "Passthrough"
)

type HyperthreadingMode Uses

type HyperthreadingMode string

HyperthreadingMode is the mode of hyperthreading for a machine. +kubebuilder:validation:Enum="";Enabled;Disabled

const (
    // HyperthreadingEnabled indicates that hyperthreading is enabled.
    HyperthreadingEnabled HyperthreadingMode = "Enabled"
    // HyperthreadingDisabled indicates that hyperthreading is disabled.
    HyperthreadingDisabled HyperthreadingMode = "Disabled"
)

type ImageContentSource Uses

type ImageContentSource struct {
    // Source is the repository that users refer to, e.g. in image pull specifications.
    Source string `json:"source"`

    // Mirrors is one or more repositories that may also contain the same images.
    // +optional
    Mirrors []string `json:"mirrors,omitempty"`
}

ImageContentSource defines a list of sources/repositories that can be used to pull content.

type InstallConfig Uses

type InstallConfig struct {
    // +optional
    metav1.TypeMeta `json:",inline"`

    metav1.ObjectMeta `json:"metadata"`

    // AdditionalTrustBundle is a PEM-encoded X.509 certificate bundle
    // that will be added to the nodes' trusted certificate store.
    //
    // +optional
    AdditionalTrustBundle string `json:"additionalTrustBundle,omitempty"`

    // SSHKey is the public Secure Shell (SSH) key to provide access to instances.
    // +optional
    SSHKey string `json:"sshKey,omitempty"`

    // BaseDomain is the base domain to which the cluster should belong.
    BaseDomain string `json:"baseDomain"`

    // Networking is the configuration for the pod network provider in
    // the cluster.
    *Networking `json:"networking,omitempty"`

    // ControlPlane is the configuration for the machines that comprise the
    // control plane.
    // +optional
    ControlPlane *MachinePool `json:"controlPlane,omitempty"`

    // Compute is the configuration for the machines that comprise the
    // compute nodes.
    // +optional
    Compute []MachinePool `json:"compute,omitempty"`

    // Platform is the configuration for the specific platform upon which to
    // perform the installation.
    Platform `json:"platform"`

    // PullSecret is the secret to use when pulling images.
    PullSecret string `json:"pullSecret"`

    // Proxy defines the proxy settings for the cluster.
    // If unset, the cluster will not be configured to use a proxy.
    // +optional
    Proxy *Proxy `json:"proxy,omitempty"`

    // ImageContentSources lists sources/repositories for the release-image content.
    // +optional
    ImageContentSources []ImageContentSource `json:"imageContentSources,omitempty"`

    // Publish controls how the user facing endpoints of the cluster like the Kubernetes API, OpenShift routes etc. are exposed.
    // When no strategy is specified, the strategy is "External".
    //
    // +kubebuilder:default=External
    // +optional
    Publish PublishingStrategy `json:"publish,omitempty"`

    // FIPS configures https://www.nist.gov/itl/fips-general-information
    //
    // +kubebuilder:default=false
    // +optional
    FIPS bool `json:"fips,omitempty"`

    // CredentialsMode is used to explicitly set the mode with which CredentialRequests are satisfied.
    //
    // If this field is set, then the installer will not attempt to query the cloud permissions before attempting
    // installation. If the field is not set or empty, then the installer will perform its normal verification that the
    // credentials provided are sufficient to perform an installation.
    //
    // There are three possible values for this field, but the valid values are dependent upon the platform being used.
    // "Mint": create new credentials with a subset of the overall permissions for each CredentialsRequest
    // "Passthrough": copy the credentials with all of the overall permissions for each CredentialsRequest
    // "Manual": CredentialsRequests must be handled manually by the user
    //
    // For each of the following platforms, the field can set to the specified values. For all other platforms, the
    // field must not be set.
    // AWS: "Mint", "Passthrough", "Manual"
    // Azure: "Mint", "Passthrough", "Manual"
    // GCP: "Mint", "Passthrough", "Manual"
    // +optional
    CredentialsMode CredentialsMode `json:"credentialsMode,omitempty"`
}

InstallConfig is the configuration for an OpenShift install.

func (*InstallConfig) ClusterDomain Uses

func (c *InstallConfig) ClusterDomain() string

ClusterDomain returns the DNS domain that all records for a cluster must belong to.

type MachineNetworkEntry Uses

type MachineNetworkEntry struct {
    // CIDR is the IP block address pool for machines within the cluster.
    CIDR ipnet.IPNet `json:"cidr"`
}

MachineNetworkEntry is a single IP address block for node IP blocks.

type MachinePool Uses

type MachinePool struct {
    // Name is the name of the machine pool.
    // For the control plane machine pool, the name will always be "master".
    // For the compute machine pools, the only valid name is "worker".
    Name string `json:"name"`

    // Replicas is the machine count for the machine pool.
    Replicas *int64 `json:"replicas,omitempty"`

    // Platform is configuration for machine pool specific to the platform.
    Platform MachinePoolPlatform `json:"platform"`

    // Hyperthreading determines the mode of hyperthreading that machines in the
    // pool will utilize.
    // Default is for hyperthreading to be enabled.
    //
    // +kubebuilder:default=Enabled
    // +optional
    Hyperthreading HyperthreadingMode `json:"hyperthreading,omitempty"`

    // Architecture is the instruction set architecture of the machine pool.
    // Defaults to amd64.
    //
    // +kubebuilder:default=amd64
    // +optional
    Architecture Architecture `json:"architecture,omitempty"`
}

MachinePool is a pool of machines to be installed.

type MachinePoolPlatform Uses

type MachinePoolPlatform struct {
    // AWS is the configuration used when installing on AWS.
    AWS *aws.MachinePool `json:"aws,omitempty"`

    // Azure is the configuration used when installing on Azure.
    Azure *azure.MachinePool `json:"azure,omitempty"`

    // BareMetal is the configuration used when installing on bare metal.
    BareMetal *baremetal.MachinePool `json:"baremetal,omitempty"`

    // GCP is the configuration used when installing on GCP
    GCP *gcp.MachinePool `json:"gcp,omitempty"`

    // Libvirt is the configuration used when installing on libvirt.
    Libvirt *libvirt.MachinePool `json:"libvirt,omitempty"`

    // OpenStack is the configuration used when installing on OpenStack.
    OpenStack *openstack.MachinePool `json:"openstack,omitempty"`

    // VSphere is the configuration used when installing on vSphere.
    VSphere *vsphere.MachinePool `json:"vsphere,omitempty"`

    // Ovirt is the configuration used when installing on oVirt.
    Ovirt *ovirt.MachinePool `json:"ovirt,omitempty"`

    // Kubevirt is the configuration used when installing on Kubevirt.
    Kubevirt *kubevirt.MachinePool `json:"kubevirt,omitempty"`
}

MachinePoolPlatform is the platform-specific configuration for a machine pool. Only one of the platforms should be set.

func (*MachinePoolPlatform) Name Uses

func (p *MachinePoolPlatform) Name() string

Name returns a string representation of the platform (e.g. "aws" if AWS is non-nil). It returns an empty string if no platform is configured.

type Networking Uses

type Networking struct {
    // NetworkType is the type of network to install. The default is OpenShiftSDN
    //
    // +kubebuilder:default=OpenShiftSDN
    // +optional
    NetworkType string `json:"networkType,omitempty"`

    // MachineNetwork is the list of IP address pools for machines.
    // This field replaces MachineCIDR, and if set MachineCIDR must
    // be empty or match the first entry in the list.
    // Default is 10.0.0.0/16 for all platforms other than libvirt.
    // For libvirt, the default is 192.168.126.0/24.
    //
    // +optional
    MachineNetwork []MachineNetworkEntry `json:"machineNetwork,omitempty"`

    // ClusterNetwork is the list of IP address pools for pods.
    // Default is 10.128.0.0/14 and a host prefix of /23.
    //
    // +optional
    ClusterNetwork []ClusterNetworkEntry `json:"clusterNetwork,omitempty"`

    // ServiceNetwork is the list of IP address pools for services.
    // Default is 172.30.0.0/16.
    // NOTE: currently only one entry is supported.
    //
    // +kubebuilder:validation:MaxItems=1
    // +optional
    ServiceNetwork []ipnet.IPNet `json:"serviceNetwork,omitempty"`

    // Deprecated name for MachineCIDRs. If set, MachineCIDRs must
    // be empty or the first index must match.
    // +optional
    DeprecatedMachineCIDR *ipnet.IPNet `json:"machineCIDR,omitempty"`

    // Deprecated name for NetworkType
    // +optional
    DeprecatedType string `json:"type,omitempty"`

    // Deprecated name for ServiceNetwork
    // +optional
    DeprecatedServiceCIDR *ipnet.IPNet `json:"serviceCIDR,omitempty"`

    // Deprecated name for ClusterNetwork
    // +optional
    DeprecatedClusterNetworks []ClusterNetworkEntry `json:"clusterNetworks,omitempty"`
}

Networking defines the pod network provider in the cluster.

type Platform Uses

type Platform struct {
    // AWS is the configuration used when installing on AWS.
    // +optional
    AWS *aws.Platform `json:"aws,omitempty"`

    // Azure is the configuration used when installing on Azure.
    // +optional
    Azure *azure.Platform `json:"azure,omitempty"`

    // BareMetal is the configuration used when installing on bare metal.
    // +optional
    BareMetal *baremetal.Platform `json:"baremetal,omitempty"`

    // GCP is the configuration used when installing on Google Cloud Platform.
    // +optional
    GCP *gcp.Platform `json:"gcp,omitempty"`

    // Libvirt is the configuration used when installing on libvirt.
    // +optional
    Libvirt *libvirt.Platform `json:"libvirt,omitempty"`

    // None is the empty configuration used when installing on an unsupported
    // platform.
    None *none.Platform `json:"none,omitempty"`

    // OpenStack is the configuration used when installing on OpenStack.
    // +optional
    OpenStack *openstack.Platform `json:"openstack,omitempty"`

    // VSphere is the configuration used when installing on vSphere.
    // +optional
    VSphere *vsphere.Platform `json:"vsphere,omitempty"`

    // Ovirt is the configuration used when installing on oVirt.
    // +optional
    Ovirt *ovirt.Platform `json:"ovirt,omitempty"`

    // Kubevirt is the configuration used when installing on kubevirt.
    // +optional
    Kubevirt *kubevirt.Platform `json:"kubevirt,omitempty"`
}

Platform is the configuration for the specific platform upon which to perform the installation. Only one of the platform configuration should be set.

func (*Platform) Name Uses

func (p *Platform) Name() string

Name returns a string representation of the platform (e.g. "aws" if AWS is non-nil). It returns an empty string if no platform is configured.

type Proxy Uses

type Proxy struct {
    // HTTPProxy is the URL of the proxy for HTTP requests.
    // +optional
    HTTPProxy string `json:"httpProxy,omitempty"`

    // HTTPSProxy is the URL of the proxy for HTTPS requests.
    // +optional
    HTTPSProxy string `json:"httpsProxy,omitempty"`

    // NoProxy is a comma-separated list of domains and CIDRs for which the proxy should not be used.
    // +optional
    NoProxy string `json:"noProxy,omitempty"`
}

Proxy defines the proxy settings for the cluster. At least one of HTTPProxy or HTTPSProxy is required.

type PublishingStrategy Uses

type PublishingStrategy string

PublishingStrategy is a strategy for how various endpoints for the cluster are exposed. +kubebuilder:validation:Enum="";External;Internal

const (
    // ExternalPublishingStrategy exposes endpoints for the cluster to the Internet.
    ExternalPublishingStrategy PublishingStrategy = "External"
    // InternalPublishingStrategy exposes the endpoints for the cluster to the private network only.
    InternalPublishingStrategy PublishingStrategy = "Internal"
)

Directories

PathSynopsis
awsPackage aws contains AWS-specific structures for installer configuration and management.
aws/defaults
aws/validation
azurePackage azure contains Azure-specific structures for installer configuration and management.
azure/defaults
azure/validation
baremetalPackage baremetal contains baremetal-specific structures for installer configuration and management.
baremetal/defaults
baremetal/validation
conversion
defaults
gcpPackage gcp contains GCP-specific structures for installer configuration and management.
gcp/defaults
gcp/validation
kubevirtPackage kubevirt contains kubevirt-specific structures for installer configuration and management.
kubevirt/defaults
kubevirt/validation
libvirtPackage libvirt contains libvirt-specific structures for installer configuration and management.
libvirt/defaults
libvirt/validation
nonePackage none contains generic structures for installer configuration and management.
none/defaults
openstackPackage openstack contains OpenStack-specific structures for installer configuration and management.
openstack/defaults
openstack/validation
ovirtPackage ovirt contains ovirt-specific structures for installer configuration and management.
ovirt/defaults
ovirt/validation
validation
vspherePackage vsphere contains vSphere-specific structures for installer configuration and management.
vsphere/defaults
vsphere/validation

Package types imports 14 packages (graph) and is imported by 68 packages. Updated 2021-01-23. Refresh now. Tools for package owners.