v1beta1

type AddressType ¶

type AddressType = v1.AddressType

AddressType defines how a network address is represented as a text string. This may take two possible forms:

* A predefined CamelCase string identifier (currently limited to `IPAddress` or `Hostname`) * A domain-prefixed string identifier (like `acme.io/CustomAddressType`)

Values `IPAddress` and `Hostname` have Extended support.

The `NamedAddress` value has been deprecated in favor of implementation specific domain-prefixed strings.

All other values, including domain-prefixed values have Implementation-specific support, which are used in implementation-specific behaviors. Support for additional predefined CamelCase identifiers may be added in future releases.

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253 +kubebuilder:validation:Pattern=`^Hostname|IPAddress|NamedAddress|[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$`

const (
	// A textual representation of a numeric IP address. IPv4
	// addresses must be in dotted-decimal form. IPv6 addresses
	// must be in a standard IPv6 text representation
	// (see [RFC 5952](https://tools.ietf.org/html/rfc5952)).
	//
	// This type is intended for specific addresses. Address ranges are not
	// supported (e.g. you can not use a CIDR range like 127.0.0.0/24 as an
	// IPAddress).
	//
	// Support: Extended
	IPAddressType AddressType = "IPAddress"

	// A Hostname represents a DNS based ingress point. This is similar to the
	// corresponding hostname field in Kubernetes load balancer status. For
	// example, this concept may be used for cloud load balancers where a DNS
	// name is used to expose a load balancer.
	//
	// Support: Extended
	HostnameAddressType AddressType = "Hostname"

	// A NamedAddress provides a way to reference a specific IP address by name.
	// For example, this may be a name or other unique identifier that refers
	// to a resource on a cloud provider such as a static IP.
	//
	// The `NamedAddress` type has been deprecated in favor of implementation
	// specific domain-prefixed strings.
	//
	// Support: Implementation-specific
	NamedAddressType AddressType = "NamedAddress"
)

type AllowedRoutes ¶

type AllowedRoutes = v1.AllowedRoutes

AllowedRoutes defines which Routes may be attached to this Listener. +k8s:deepcopy-gen=false

type AnnotationKey ¶

type AnnotationKey = v1.AnnotationKey

AnnotationKey is the key of an annotation in Gateway API. This is used for validation of maps such as TLS options. This matches the Kubernetes "qualified name" validation that is used for annotations and other common values.

Valid values include:

* example * example.com * example.com/path * example.com/path.html

Invalid values include:

* example~ - "~" is an invalid character * example.com. - can not start or end with "."

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253 +kubebuilder:validation:Pattern=`^(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]/?)*$`

type AnnotationValue ¶

type AnnotationValue = v1.AnnotationValue

AnnotationValue is the value of an annotation in Gateway API. This is used for validation of maps such as TLS options. This roughly matches Kubernetes annotation validation, although the length validation in that case is based on the entire size of the annotations struct.

+kubebuilder:validation:MinLength=0 +kubebuilder:validation:MaxLength=4096

type BackendObjectReference ¶

type BackendObjectReference = v1.BackendObjectReference

BackendObjectReference defines how an ObjectReference that is specific to BackendRef. It includes a few additional fields and features than a regular ObjectReference.

Note that when a namespace different than the local namespace is specified, a ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details.

The API object must be valid in the cluster; the Group and Kind must be registered in the cluster for this reference to be valid.

References to objects with invalid Group and Kind are not valid, and must be rejected by the implementation, with appropriate Conditions set on the containing object. +k8s:deepcopy-gen=false

type BackendRef ¶

type BackendRef = v1.BackendRef

BackendRef defines how a Route should forward a request to a Kubernetes resource.

Note that when a namespace different than the local namespace is specified, a ReferenceGrant object is required in the referent namespace to allow that namespace's owner to accept the reference. See the ReferenceGrant documentation for details. +k8s:deepcopy-gen=false

type CommonRouteSpec ¶

type CommonRouteSpec = v1.CommonRouteSpec

CommonRouteSpec defines the common attributes that all Routes MUST include within their spec. +k8s:deepcopy-gen=false

type Duration ¶ added in v0.8.1

type Duration = v1.Duration

Duration is a string value representing a duration in time. The format is as specified in GEP-2257, a strict subset of the syntax parsed by Golang time.ParseDuration.

type FromNamespaces ¶

type FromNamespaces = v1.FromNamespaces

FromNamespaces specifies namespace from which Routes may be attached to a Gateway.

Note that values may be added to this enum, implementations must ensure that unknown values will not cause a crash.

Unknown values here must result in the implementation setting the Ready Condition for the Listener to `status: False`, with a Reason of `Invalid`.

+kubebuilder:validation:Enum=All;Selector;Same +k8s:deepcopy-gen=false

type Gateway ¶

type Gateway v1.Gateway

Gateway represents an instance of a service-traffic handling infrastructure by binding Listeners to a set of IP addresses.

func (in *Gateway) DeepCopy() *Gateway

func (in *Gateway) DeepCopyInto(out *Gateway)

func (in *Gateway) DeepCopyObject() runtime.Object

type GatewayAddress ¶

type GatewayAddress = v1.GatewayAddress

GatewayAddress describes an address that can be bound to a Gateway. +k8s:deepcopy-gen=false

type GatewayClass ¶

type GatewayClass v1.GatewayClass

GatewayClass describes a class of Gateways available to the user for creating Gateway resources.

It is recommended that this resource be used as a template for Gateways. This means that a Gateway is based on the state of the GatewayClass at the time it was created and changes to the GatewayClass or associated parameters are not propagated down to existing Gateways. This recommendation is intended to limit the blast radius of changes to GatewayClass or associated parameters. If implementations choose to propagate GatewayClass changes to existing Gateways, that MUST be clearly documented by the implementation.

Whenever one or more Gateways are using a GatewayClass, implementations SHOULD add the `gateway-exists-finalizer.gateway.networking.k8s.io` finalizer on the associated GatewayClass. This ensures that a GatewayClass associated with a Gateway is not deleted while in use.

GatewayClass is a Cluster level resource.

func (in *GatewayClass) DeepCopy() *GatewayClass

func (in *GatewayClass) DeepCopyInto(out *GatewayClass)

func (in *GatewayClass) DeepCopyObject() runtime.Object

type GatewayClassConditionReason ¶

type GatewayClassConditionReason = v1.GatewayClassConditionReason

GatewayClassConditionReason defines the set of reasons that explain why a particular GatewayClass condition type has been raised. +k8s:deepcopy-gen=false

type GatewayClassConditionType ¶

type GatewayClassConditionType = v1.GatewayClassConditionType

GatewayClassConditionType is the type for status conditions on Gateway resources. This type should be used with the GatewayClassStatus.Conditions field. +k8s:deepcopy-gen=false

type GatewayClassList ¶

type GatewayClassList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []GatewayClass `json:"items"`
}

GatewayClassList contains a list of GatewayClass

func (in *GatewayClassList) DeepCopy() *GatewayClassList

func (in *GatewayClassList) DeepCopyInto(out *GatewayClassList)

func (in *GatewayClassList) DeepCopyObject() runtime.Object

type GatewayClassSpec ¶

type GatewayClassSpec = v1.GatewayClassSpec

GatewayClassSpec reflects the configuration of a class of Gateways. +k8s:deepcopy-gen=false

type GatewayClassStatus ¶

type GatewayClassStatus = v1.GatewayClassStatus

GatewayClassStatus is the current status for the GatewayClass. +k8s:deepcopy-gen=false

type GatewayConditionReason ¶

type GatewayConditionReason = v1.GatewayConditionReason

GatewayConditionReason defines the set of reasons that explain why a particular Gateway condition type has been raised. +k8s:deepcopy-gen=false

type GatewayConditionType ¶

type GatewayConditionType = v1.GatewayConditionType

GatewayConditionType is a type of condition associated with a Gateway. This type should be used with the GatewayStatus.Conditions field. +k8s:deepcopy-gen=false

type GatewayController ¶

type GatewayController = v1.GatewayController

GatewayController is the name of a Gateway API controller. It must be a domain prefixed path.

Valid values include:

* "example.com/bar"

Invalid values include:

* "example.com" - must include path * "foo.example.com" - must include path

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253 +kubebuilder:validation:Pattern=`^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$`

type GatewayList ¶

type GatewayList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Gateway `json:"items"`
}

GatewayList contains a list of Gateways.

func (in *GatewayList) DeepCopy() *GatewayList

func (in *GatewayList) DeepCopyInto(out *GatewayList)

func (in *GatewayList) DeepCopyObject() runtime.Object

type GatewaySpec ¶

type GatewaySpec = v1.GatewaySpec

GatewaySpec defines the desired state of Gateway.

Not all possible combinations of options specified in the Spec are valid. Some invalid configurations can be caught synchronously via a webhook, but there are many cases that will require asynchronous signaling via the GatewayStatus block. +k8s:deepcopy-gen=false

type GatewayStatus ¶

type GatewayStatus = v1.GatewayStatus

GatewayStatus defines the observed state of Gateway. +k8s:deepcopy-gen=false

type GatewayTLSConfig ¶

type GatewayTLSConfig = v1.GatewayTLSConfig

GatewayTLSConfig describes a TLS configuration. +k8s:deepcopy-gen=false

type Group ¶

type Group = v1.Group

Group refers to a Kubernetes Group. It must either be an empty string or a RFC 1123 subdomain.

This validation is based off of the corresponding Kubernetes validation: https://github.com/kubernetes/apimachinery/blob/02cfb53916346d085a6c6c7c66f882e3c6b0eca6/pkg/util/validation/validation.go#L208

Valid values include:

* "" - empty string implies core Kubernetes API group * "networking.k8s.io" * "foo.example.com"

Invalid values include:

* "example.com/bar" - "/" is an invalid character

+kubebuilder:validation:MaxLength=253 +kubebuilder:validation:Pattern=`^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$`

type HTTPBackendRef ¶

type HTTPBackendRef = v1.HTTPBackendRef

HTTPBackendRef defines how a HTTPRoute should forward an HTTP request. +k8s:deepcopy-gen=false

type HTTPHeader ¶

type HTTPHeader = v1.HTTPHeader

HTTPHeader represents an HTTP Header name and value as defined by RFC 7230. +k8s:deepcopy-gen=false

type HTTPHeaderFilter ¶ added in v0.6.0

type HTTPHeaderFilter = v1.HTTPHeaderFilter

HTTPHeaderFilter defines a filter that modifies the headers of an HTTP request or response. +k8s:deepcopy-gen=false

type HTTPHeaderMatch ¶

type HTTPHeaderMatch = v1.HTTPHeaderMatch

HTTPHeaderMatch describes how to select a HTTP route by matching HTTP request headers. +k8s:deepcopy-gen=false

type HTTPHeaderName ¶

type HTTPHeaderName = v1.HeaderName

HTTPHeaderName is the name of an HTTP header.

Valid values include: * "Authorization" * "Set-Cookie"

Invalid values include:

• ":method" - ":" is an invalid character. This means that HTTP/2 pseudo headers are not currently supported by this type.

* "/invalid" - "/" is an invalid character +k8s:deepcopy-gen=false

type HTTPMethod ¶

type HTTPMethod = v1.HTTPMethod

HTTPMethod describes how to select a HTTP route by matching the HTTP method as defined by [RFC 7231](https://datatracker.ietf.org/doc/html/rfc7231#section-4) and [RFC 5789](https://datatracker.ietf.org/doc/html/rfc5789#section-2). The value is expected in upper case.

Note that values may be added to this enum, implementations must ensure that unknown values will not cause a crash.

Unknown values here must result in the implementation setting the Accepted Condition for the Route to `status: False`, with a Reason of `UnsupportedValue`.

+kubebuilder:validation:Enum=GET;HEAD;POST;PUT;DELETE;CONNECT;OPTIONS;TRACE;PATCH +k8s:deepcopy-gen=false

type HTTPPathMatch ¶

type HTTPPathMatch = v1.HTTPPathMatch

HTTPPathMatch describes how to select a HTTP route by matching the HTTP request path. +k8s:deepcopy-gen=false

type HTTPPathModifier ¶

type HTTPPathModifier = v1.HTTPPathModifier

HTTPPathModifier defines configuration for path modifiers. <gateway:experimental> +k8s:deepcopy-gen=false

type HTTPPathModifierType ¶

type HTTPPathModifierType = v1.HTTPPathModifierType

HTTPPathModifierType defines the type of path redirect or rewrite. +k8s:deepcopy-gen=false

type HTTPQueryParamMatch ¶

type HTTPQueryParamMatch = v1.HTTPQueryParamMatch

HTTPQueryParamMatch describes how to select a HTTP route by matching HTTP query parameters. +k8s:deepcopy-gen=false

type HTTPRequestMirrorFilter ¶

type HTTPRequestMirrorFilter = v1.HTTPRequestMirrorFilter

HTTPRequestMirrorFilter defines configuration for the RequestMirror filter. +k8s:deepcopy-gen=false

type HTTPRequestRedirectFilter ¶

type HTTPRequestRedirectFilter = v1.HTTPRequestRedirectFilter

HTTPRequestRedirect defines a filter that redirects a request. This filter MUST NOT be used on the same Route rule as a HTTPURLRewrite filter. +k8s:deepcopy-gen=false

type HTTPRoute ¶

type HTTPRoute v1.HTTPRoute

HTTPRoute provides a way to route HTTP requests. This includes the capability to match requests by hostname, path, header, or query param. Filters can be used to specify additional processing steps. Backends specify where matching requests should be routed.

func (in *HTTPRoute) DeepCopy() *HTTPRoute

func (in *HTTPRoute) DeepCopyInto(out *HTTPRoute)

func (in *HTTPRoute) DeepCopyObject() runtime.Object

type HTTPRouteFilter ¶

type HTTPRouteFilter = v1.HTTPRouteFilter

HTTPRouteFilter defines processing steps that must be completed during the request or response lifecycle. HTTPRouteFilters are meant as an extension point to express processing that may be done in Gateway implementations. Some examples include request or response modification, implementing authentication strategies, rate-limiting, and traffic shaping. API guarantee/conformance is defined based on the type of the filter. +k8s:deepcopy-gen=false

type HTTPRouteFilterType ¶

type HTTPRouteFilterType = v1.HTTPRouteFilterType

HTTPRouteFilterType identifies a type of HTTPRoute filter. +k8s:deepcopy-gen=false

type HTTPRouteList ¶

type HTTPRouteList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []HTTPRoute `json:"items"`
}

HTTPRouteList contains a list of HTTPRoute.

func (in *HTTPRouteList) DeepCopy() *HTTPRouteList

func (in *HTTPRouteList) DeepCopyInto(out *HTTPRouteList)

func (in *HTTPRouteList) DeepCopyObject() runtime.Object

type HTTPRouteMatch ¶

type HTTPRouteMatch = v1.HTTPRouteMatch

HTTPRouteMatch defines the predicate used to match requests to a given action. Multiple match types are ANDed together, i.e. the match will evaluate to true only if all conditions are satisfied.

For example, the match below will match a HTTP request only if its path starts with `/foo` AND it contains the `version: v1` header:

``` match:

path:
  value: "/foo"
headers:
- name: "version"
  value "v1"

``` +k8s:deepcopy-gen=false

type HTTPRouteRule ¶

type HTTPRouteRule = v1.HTTPRouteRule

HTTPRouteRule defines semantics for matching an HTTP request based on conditions (matches), processing it (filters), and forwarding the request to an API object (backendRefs). +k8s:deepcopy-gen=false

type HTTPRouteSpec ¶

type HTTPRouteSpec = v1.HTTPRouteSpec

HTTPRouteSpec defines the desired state of HTTPRoute +k8s:deepcopy-gen=false

type HTTPRouteStatus ¶

type HTTPRouteStatus = v1.HTTPRouteStatus

HTTPRouteStatus defines the observed state of HTTPRoute. +k8s:deepcopy-gen=false

type HTTPRouteTimeouts ¶ added in v0.8.1

type HTTPRouteTimeouts = v1.HTTPRouteTimeouts

HTTPRouteTimeouts defines timeouts that can be configured for an HTTPRoute. +k8s:deepcopy-gen=false

type HTTPURLRewriteFilter ¶

type HTTPURLRewriteFilter = v1.HTTPURLRewriteFilter

HTTPURLRewriteFilter defines a filter that modifies a request during forwarding. At most one of these filters may be used on a Route rule. This MUST NOT be used on the same Route rule as a HTTPRequestRedirect filter.

Support: Extended

<gateway:experimental> +k8s:deepcopy-gen=false

type HeaderMatchType ¶

type HeaderMatchType = v1.HeaderMatchType

HeaderMatchType specifies the semantics of how HTTP header values should be compared. Valid HeaderMatchType values, along with their conformance levels, are:

* "Exact" - Core * "RegularExpression" - Implementation Specific

Note that values may be added to this enum, implementations must ensure that unknown values will not cause a crash.

Unknown values here must result in the implementation setting the Accepted Condition for the Route to `status: False`, with a Reason of `UnsupportedValue`.

+kubebuilder:validation:Enum=Exact;RegularExpression +k8s:deepcopy-gen=false

type Hostname ¶

type Hostname = v1.Hostname

Hostname is the fully qualified domain name of a network host. This matches the RFC 1123 definition of a hostname with 2 notable exceptions:

1. IPs are not allowed.
2. A hostname may be prefixed with a wildcard label (`*.`). The wildcard label must appear by itself as the first label.

Hostname can be "precise" which is a domain name without the terminating dot of a network host (e.g. "foo.example.com") or "wildcard", which is a domain name prefixed with a single wildcard label (e.g. `*.example.com`).

Note that as per RFC1035 and RFC1123, a *label* must consist of lower case alphanumeric characters or '-', and must start and end with an alphanumeric character. No other punctuation is allowed.

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253 +kubebuilder:validation:Pattern=`^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$`

type Kind ¶

type Kind = v1.Kind

Kind refers to a Kubernetes Kind.

Valid values include:

* "Service" * "HTTPRoute"

Invalid values include:

* "invalid/kind" - "/" is an invalid character

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=63 +kubebuilder:validation:Pattern=`^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$`

type Listener ¶

type Listener = v1.Listener

Listener embodies the concept of a logical endpoint where a Gateway accepts network connections. +k8s:deepcopy-gen=false

type ListenerConditionReason ¶

type ListenerConditionReason = v1.ListenerConditionReason

ListenerConditionReason defines the set of reasons that explain why a particular Listener condition type has been raised. +k8s:deepcopy-gen=false

type ListenerConditionType ¶

type ListenerConditionType = v1.ListenerConditionType

ListenerConditionType is a type of condition associated with the listener. This type should be used with the ListenerStatus.Conditions field. +k8s:deepcopy-gen=false

type ListenerStatus ¶

type ListenerStatus = v1.ListenerStatus

ListenerStatus is the status associated with a Listener. +k8s:deepcopy-gen=false

type LocalObjectReference ¶

type LocalObjectReference = v1.LocalObjectReference

LocalObjectReference identifies an API object within the namespace of the referrer. The API object must be valid in the cluster; the Group and Kind must be registered in the cluster for this reference to be valid.

References to objects with invalid Group and Kind are not valid, and must be rejected by the implementation, with appropriate Conditions set on the containing object. +k8s:deepcopy-gen=false

type Namespace ¶

type Namespace = v1.Namespace

Namespace refers to a Kubernetes namespace. It must be a RFC 1123 label.

This validation is based off of the corresponding Kubernetes validation: https://github.com/kubernetes/apimachinery/blob/02cfb53916346d085a6c6c7c66f882e3c6b0eca6/pkg/util/validation/validation.go#L187

This is used for Namespace name validation here: https://github.com/kubernetes/apimachinery/blob/02cfb53916346d085a6c6c7c66f882e3c6b0eca6/pkg/api/validation/generic.go#L63

Valid values include:

* "example"

Invalid values include:

* "example.com" - "." is an invalid character

+kubebuilder:validation:Pattern=`^[a-z0-9]([-a-z0-9]*[a-z0-9])?$` +kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=63

type ObjectName ¶

type ObjectName = v1.ObjectName

ObjectName refers to the name of a Kubernetes object. Object names can have a variety of forms, including RFC1123 subdomains, RFC 1123 labels, or RFC 1035 labels.

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253

type ParametersReference ¶

type ParametersReference = v1.ParametersReference

ParametersReference identifies an API object containing controller-specific configuration resource within the cluster. +k8s:deepcopy-gen=false

type ParentReference ¶

type ParentReference = v1.ParentReference

ParentReference identifies an API object (usually a Gateway) that can be considered a parent of this resource (usually a route). The only kind of parent resource with "Core" support is Gateway. This API may be extended in the future to support additional kinds of parent resources, such as HTTPRoute.

Note that there are specific rules for ParentRefs which cross namespace boundaries. Cross-namespace references are only valid if they are explicitly allowed by something in the namespace they are referring to. For example: Gateway has the AllowedRoutes field, and ReferenceGrant provides a generic way to enable any other kind of cross-namespace reference.

The API object must be valid in the cluster; the Group and Kind must be registered in the cluster for this reference to be valid. +k8s:deepcopy-gen=false

type PathMatchType ¶

type PathMatchType = v1.PathMatchType

PathMatchType specifies the semantics of how HTTP paths should be compared. Valid PathMatchType values, along with their conformance level, are:

* "Exact" - Core * "PathPrefix" - Core * "RegularExpression" - Implementation Specific

PathPrefix and Exact paths must be syntactically valid:

- Must begin with the `/` character - Must not contain consecutive `/` characters (e.g. `/foo///`, `//`).

Note that values may be added to this enum, implementations must ensure that unknown values will not cause a crash.

Unknown values here must result in the implementation setting the Accepted Condition for the Route to `status: False`, with a Reason of `UnsupportedValue`.

+kubebuilder:validation:Enum=Exact;PathPrefix;RegularExpression +k8s:deepcopy-gen=false

type PortNumber ¶

type PortNumber = v1.PortNumber

PortNumber defines a network port.

+kubebuilder:validation:Minimum=1 +kubebuilder:validation:Maximum=65535

type PreciseHostname ¶

type PreciseHostname = v1.PreciseHostname

PreciseHostname is the fully qualified domain name of a network host. This matches the RFC 1123 definition of a hostname with 1 notable exception that numeric IP addresses are not allowed.

Note that as per RFC1035 and RFC1123, a *label* must consist of lower case alphanumeric characters or '-', and must start and end with an alphanumeric character. No other punctuation is allowed.

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253 +kubebuilder:validation:Pattern=`^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$`

type ProtocolType ¶

type ProtocolType = v1.ProtocolType

ProtocolType defines the application protocol accepted by a Listener. Implementations are not required to accept all the defined protocols. If an implementation does not support a specified protocol, it MUST set the "Accepted" condition to False for the affected Listener with a reason of "UnsupportedProtocol".

Core ProtocolType values are listed in the table below.

Implementations can define their own protocols if a core ProtocolType does not exist. Such definitions must use prefixed name, such as `mycompany.com/my-custom-protocol`. Un-prefixed names are reserved for core protocols. Any protocol defined by implementations will fall under implementation-specific conformance.

Valid values include:

* "HTTP" - Core support * "example.com/bar" - Implementation-specific support

Invalid values include:

* "example.com" - must include path if domain is used * "foo.example.com" - must include path if domain is used

+kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=255 +kubebuilder:validation:Pattern=`^[a-zA-Z0-9]([-a-zSA-Z0-9]*[a-zA-Z0-9])?$|[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9]+$` +k8s:deepcopy-gen=false

type QueryParamMatchType ¶

type QueryParamMatchType = v1.QueryParamMatchType

QueryParamMatchType specifies the semantics of how HTTP query parameter values should be compared. Valid QueryParamMatchType values, along with their conformance levels, are:

* "Exact" - Core * "RegularExpression" - Implementation Specific

Note that values may be added to this enum, implementations must ensure that unknown values will not cause a crash.

Unknown values here must result in the implementation setting the Accepted Condition for the Route to `status: False`, with a Reason of `UnsupportedValue`.

+kubebuilder:validation:Enum=Exact;RegularExpression +k8s:deepcopy-gen=false

type ReferenceGrant ¶ added in v0.6.0

type ReferenceGrant struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// Spec defines the desired state of ReferenceGrant.
	Spec ReferenceGrantSpec `json:"spec,omitempty"`
}

ReferenceGrant identifies kinds of resources in other namespaces that are trusted to reference the specified kinds of resources in the same namespace as the policy.

Each ReferenceGrant can be used to represent a unique trust relationship. Additional Reference Grants can be used to add to the set of trusted sources of inbound references for the namespace they are defined within.

All cross-namespace references in Gateway API (with the exception of cross-namespace Gateway-route attachment) require a ReferenceGrant.

ReferenceGrant is a form of runtime verification allowing users to assert which cross-namespace object references are permitted. Implementations that support ReferenceGrant MUST NOT permit cross-namespace references which have no grant, and MUST respond to the removal of a grant by revoking the access that the grant allowed.

func (in *ReferenceGrant) DeepCopy() *ReferenceGrant

func (in *ReferenceGrant) DeepCopyInto(out *ReferenceGrant)

func (in *ReferenceGrant) DeepCopyObject() runtime.Object

type ReferenceGrantFrom ¶ added in v0.6.0

type ReferenceGrantFrom struct {
	// Group is the group of the referent.
	// When empty, the Kubernetes core API group is inferred.
	//
	// Support: Core
	Group Group `json:"group"`

	// Kind is the kind of the referent. Although implementations may support
	// additional resources, the following types are part of the "Core"
	// support level for this field.
	//
	// When used to permit a SecretObjectReference:
	//
	// * Gateway
	//
	// When used to permit a BackendObjectReference:
	//
	// * GRPCRoute
	// * HTTPRoute
	// * TCPRoute
	// * TLSRoute
	// * UDPRoute
	Kind Kind `json:"kind"`

	// Namespace is the namespace of the referent.
	//
	// Support: Core
	Namespace Namespace `json:"namespace"`
}

ReferenceGrantFrom describes trusted namespaces and kinds.

func (in *ReferenceGrantFrom) DeepCopy() *ReferenceGrantFrom

func (in *ReferenceGrantFrom) DeepCopyInto(out *ReferenceGrantFrom)

type ReferenceGrantList ¶ added in v0.6.0

type ReferenceGrantList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []ReferenceGrant `json:"items"`
}

+kubebuilder:object:root=true ReferenceGrantList contains a list of ReferenceGrant.

func (in *ReferenceGrantList) DeepCopy() *ReferenceGrantList

func (in *ReferenceGrantList) DeepCopyInto(out *ReferenceGrantList)

func (in *ReferenceGrantList) DeepCopyObject() runtime.Object

type ReferenceGrantSpec ¶ added in v0.6.0

type ReferenceGrantSpec struct {
	// From describes the trusted namespaces and kinds that can reference the
	// resources described in "To". Each entry in this list MUST be considered
	// to be an additional place that references can be valid from, or to put
	// this another way, entries MUST be combined using OR.
	//
	// Support: Core
	//
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	From []ReferenceGrantFrom `json:"from"`

	// To describes the resources that may be referenced by the resources
	// described in "From". Each entry in this list MUST be considered to be an
	// additional place that references can be valid to, or to put this another
	// way, entries MUST be combined using OR.
	//
	// Support: Core
	//
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=16
	To []ReferenceGrantTo `json:"to"`
}

ReferenceGrantSpec identifies a cross namespace relationship that is trusted for Gateway API.

func (in *ReferenceGrantSpec) DeepCopy() *ReferenceGrantSpec

func (in *ReferenceGrantSpec) DeepCopyInto(out *ReferenceGrantSpec)

type ReferenceGrantTo ¶ added in v0.6.0

type ReferenceGrantTo struct {
	// Group is the group of the referent.
	// When empty, the Kubernetes core API group is inferred.
	//
	// Support: Core
	Group Group `json:"group"`

	// Kind is the kind of the referent. Although implementations may support
	// additional resources, the following types are part of the "Core"
	// support level for this field:
	//
	// * Secret when used to permit a SecretObjectReference
	// * Service when used to permit a BackendObjectReference
	Kind Kind `json:"kind"`

	// Name is the name of the referent. When unspecified, this policy
	// refers to all resources of the specified Group and Kind in the local
	// namespace.
	//
	// +optional
	Name *ObjectName `json:"name,omitempty"`
}

ReferenceGrantTo describes what Kinds are allowed as targets of the references.

func (in *ReferenceGrantTo) DeepCopy() *ReferenceGrantTo

func (in *ReferenceGrantTo) DeepCopyInto(out *ReferenceGrantTo)

type RouteConditionReason ¶

type RouteConditionReason = v1.RouteConditionReason

RouteConditionReason is a reason for a route condition.

type RouteConditionType ¶

type RouteConditionType = v1.RouteConditionType

RouteConditionType is a type of condition for a route.

type RouteGroupKind ¶

type RouteGroupKind = v1.RouteGroupKind

RouteGroupKind indicates the group and kind of a Route resource. +k8s:deepcopy-gen=false

type RouteNamespaces ¶

type RouteNamespaces = v1.RouteNamespaces

RouteNamespaces indicate which namespaces Routes should be selected from. +k8s:deepcopy-gen=false

type RouteParentStatus ¶

type RouteParentStatus = v1.RouteParentStatus

RouteParentStatus describes the status of a route with respect to an associated Parent. +k8s:deepcopy-gen=false

type RouteStatus ¶

type RouteStatus = v1.RouteStatus

RouteStatus defines the common attributes that all Routes MUST include within their status. +k8s:deepcopy-gen=false

type SecretObjectReference ¶

type SecretObjectReference = v1.SecretObjectReference

SecretObjectReference identifies an API object including its namespace, defaulting to Secret.

The API object must be valid in the cluster; the Group and Kind must be registered in the cluster for this reference to be valid.

References to objects with invalid Group and Kind are not valid, and must be rejected by the implementation, with appropriate Conditions set on the containing object. +k8s:deepcopy-gen=false

type SectionName ¶

type SectionName = v1.SectionName

SectionName is the name of a section in a Kubernetes resource.

This validation is based off of the corresponding Kubernetes validation: https://github.com/kubernetes/apimachinery/blob/02cfb53916346d085a6c6c7c66f882e3c6b0eca6/pkg/util/validation/validation.go#L208

Valid values include:

* "example.com" * "foo.example.com"

Invalid values include:

* "example.com/bar" - "/" is an invalid character

+kubebuilder:validation:Pattern=`^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$` +kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253

type TLSModeType ¶

type TLSModeType = v1.TLSModeType

TLSModeType type defines how a Gateway handles TLS sessions.

Note that values may be added to this enum, implementations must ensure that unknown values will not cause a crash.

Unknown values here must result in the implementation setting the Ready Condition for the Listener to `status: False`, with a Reason of `Invalid`.

+kubebuilder:validation:Enum=Terminate;Passthrough +k8s:deepcopy-gen=false