const (
// This condition indicates whether the route has been accepted or rejected
// by a Gateway, and why.
//
// Possible reasons for this condition to be true are:
//
// * "Accepted"
//
// Possible reasons for this condition to be False are:
//
// * "NotAllowedByListeners"
// * "NoMatchingListenerHostname"
// * "UnsupportedValue"
//
// Possible reasons for this condition to be Unknown are:
//
// * "Pending"
//
// Controllers may raise this condition with other reasons,
// but should prefer to use the reasons listed above to improve
// interoperability.
RouteConditionAccepted RouteConditionType = "Accepted"
// This reason is used with the "Accepted" condition when the Route has been
// accepted by the Gateway.
RouteReasonAccepted RouteConditionReason = "Accepted"
// This reason is used with the "Accepted" condition when the route has not
// been accepted by a Gateway because the Gateway has no Listener whose
// allowedRoutes criteria permit the route
RouteReasonNotAllowedByListeners RouteConditionReason = "NotAllowedByListeners"
// This reason is used with the "Accepted" condition when the Gateway has no
// compatible Listeners whose Hostname matches the route
RouteReasonNoMatchingListenerHostname RouteConditionReason = "NoMatchingListenerHostname"
// This reason is used with the "Accepted" condition when a value for an Enum
// is not recognized.
RouteReasonUnsupportedValue RouteConditionReason = "UnsupportedValue"
// This reason is used with the "Accepted" when a controller has not yet
// reconciled the route.
RouteReasonPending RouteConditionReason = "Pending"
// This condition indicates whether the controller was able to resolve all
// the object references for the Route.
//
// Possible reasons for this condition to be true are:
//
// * "ResolvedRefs"
//
// Possible reasons for this condition to be false are:
//
// * "RefNotPermitted"
// * "InvalidKind"
// * "BackendNotFound"
//
// Controllers may raise this condition with other reasons,
// but should prefer to use the reasons listed above to improve
// interoperability.
RouteConditionResolvedRefs RouteConditionType = "ResolvedRefs"
// This reason is used with the "ResolvedRefs" condition when the condition
// is true.
RouteReasonResolvedRefs RouteConditionReason = "ResolvedRefs"
// This reason is used with the "ResolvedRefs" condition when
// one of the Listener's Routes has a BackendRef to an object in
// another namespace, where the object in the other namespace does
// not have a ReferenceGrant explicitly allowing the reference.
RouteReasonRefNotPermitted RouteConditionReason = "RefNotPermitted"
// This reason is used with the "ResolvedRefs" condition when
// one of the Route's rules has a reference to an unknown or unsupported
// Group and/or Kind.
RouteReasonInvalidKind RouteConditionReason = "InvalidKind"
// This reason is used with the "ResolvedRefs" condition when one of the
// Route's rules has a reference to a resource that does not exist.
RouteReasonBackendNotFound RouteConditionReason = "BackendNotFound"
)
GroupName specifies the group name used to register the objects.
const GroupName = "gateway.networking.k8s.io"
var (
// localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes.
SchemeBuilder runtime.SchemeBuilder
// Depreciated: use Install instead
AddToScheme = localSchemeBuilder.AddToScheme
Install = localSchemeBuilder.AddToScheme
)
GroupVersion specifies the group and the version used to register the objects.
var GroupVersion = v1.GroupVersion{Group: GroupName, Version: "v1beta1"}
SchemeGroupVersion is group version used to register these objects Deprecated: use GroupVersion instead.
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}
func Resource(resource string) schema.GroupResource
Resource takes an unqualified resource and returns a Group qualified GroupResource
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\/\-._~%!$&'()*+,;=:]+$`
type AddressType = v1.AddressType
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"
)
AllowedRoutes defines which Routes may be attached to this Listener. +k8s:deepcopy-gen=false
type AllowedRoutes = v1.AllowedRoutes
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 AnnotationKey = v1.AnnotationKey
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 AnnotationValue = v1.AnnotationValue
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 BackendObjectReference = v1.BackendObjectReference
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 BackendRef = v1.BackendRef
CommonRouteSpec defines the common attributes that all Routes MUST include within their spec. +k8s:deepcopy-gen=false
type CommonRouteSpec = v1.CommonRouteSpec
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 Duration = v1.Duration
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 FromNamespaces = v1.FromNamespaces
Gateway represents an instance of a service-traffic handling infrastructure by binding Listeners to a set of IP addresses.
type Gateway v1.Gateway
func (in *Gateway) DeepCopy() *Gateway
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Gateway.
func (in *Gateway) DeepCopyInto(out *Gateway)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *Gateway) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
GatewayAddress describes an address that can be bound to a Gateway. +k8s:deepcopy-gen=false
type GatewayAddress = v1.GatewayAddress
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.
type GatewayClass v1.GatewayClass
func (in *GatewayClass) DeepCopy() *GatewayClass
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayClass.
func (in *GatewayClass) DeepCopyInto(out *GatewayClass)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GatewayClass) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
GatewayClassConditionReason defines the set of reasons that explain why a particular GatewayClass condition type has been raised. +k8s:deepcopy-gen=false
type GatewayClassConditionReason = v1.GatewayClassConditionReason
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 GatewayClassConditionType = v1.GatewayClassConditionType
GatewayClassList contains a list of GatewayClass
type GatewayClassList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []GatewayClass `json:"items"`
}
func (in *GatewayClassList) DeepCopy() *GatewayClassList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayClassList.
func (in *GatewayClassList) DeepCopyInto(out *GatewayClassList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GatewayClassList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
GatewayClassSpec reflects the configuration of a class of Gateways. +k8s:deepcopy-gen=false
type GatewayClassSpec = v1.GatewayClassSpec
GatewayClassStatus is the current status for the GatewayClass. +k8s:deepcopy-gen=false
type GatewayClassStatus = v1.GatewayClassStatus
GatewayConditionReason defines the set of reasons that explain why a particular Gateway condition type has been raised. +k8s:deepcopy-gen=false
type GatewayConditionReason = v1.GatewayConditionReason
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 GatewayConditionType = v1.GatewayConditionType
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 GatewayController = v1.GatewayController
GatewayList contains a list of Gateways.
type GatewayList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []Gateway `json:"items"`
}
func (in *GatewayList) DeepCopy() *GatewayList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayList.
func (in *GatewayList) DeepCopyInto(out *GatewayList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *GatewayList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
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 GatewaySpec = v1.GatewaySpec
GatewayStatus defines the observed state of Gateway. +k8s:deepcopy-gen=false
type GatewayStatus = v1.GatewayStatus
GatewayTLSConfig describes a TLS configuration. +k8s:deepcopy-gen=false
type GatewayTLSConfig = v1.GatewayTLSConfig
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 Group = v1.Group
HTTPBackendRef defines how a HTTPRoute should forward an HTTP request. +k8s:deepcopy-gen=false
type HTTPBackendRef = v1.HTTPBackendRef
HTTPHeader represents an HTTP Header name and value as defined by RFC 7230. +k8s:deepcopy-gen=false
type HTTPHeader = v1.HTTPHeader
HTTPHeaderFilter defines a filter that modifies the headers of an HTTP request or response. +k8s:deepcopy-gen=false
type HTTPHeaderFilter = v1.HTTPHeaderFilter
HTTPHeaderMatch describes how to select a HTTP route by matching HTTP request headers. +k8s:deepcopy-gen=false
type HTTPHeaderMatch = v1.HTTPHeaderMatch
HTTPHeaderName is the name of an HTTP header.
Valid values include: * "Authorization" * "Set-Cookie"
Invalid values include:
* "/invalid" - "/" is an invalid character +k8s:deepcopy-gen=false
type HTTPHeaderName = v1.HeaderName
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 HTTPMethod = v1.HTTPMethod
HTTPPathMatch describes how to select a HTTP route by matching the HTTP request path. +k8s:deepcopy-gen=false
type HTTPPathMatch = v1.HTTPPathMatch
HTTPPathModifier defines configuration for path modifiers. <gateway:experimental> +k8s:deepcopy-gen=false
type HTTPPathModifier = v1.HTTPPathModifier
HTTPPathModifierType defines the type of path redirect or rewrite. +k8s:deepcopy-gen=false
type HTTPPathModifierType = v1.HTTPPathModifierType
HTTPQueryParamMatch describes how to select a HTTP route by matching HTTP query parameters. +k8s:deepcopy-gen=false
type HTTPQueryParamMatch = v1.HTTPQueryParamMatch
HTTPRequestMirrorFilter defines configuration for the RequestMirror filter. +k8s:deepcopy-gen=false
type HTTPRequestMirrorFilter = v1.HTTPRequestMirrorFilter
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 HTTPRequestRedirectFilter = v1.HTTPRequestRedirectFilter
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.
type HTTPRoute v1.HTTPRoute
func (in *HTTPRoute) DeepCopy() *HTTPRoute
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRoute.
func (in *HTTPRoute) DeepCopyInto(out *HTTPRoute)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HTTPRoute) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
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 HTTPRouteFilter = v1.HTTPRouteFilter
HTTPRouteFilterType identifies a type of HTTPRoute filter. +k8s:deepcopy-gen=false
type HTTPRouteFilterType = v1.HTTPRouteFilterType
HTTPRouteList contains a list of HTTPRoute.
type HTTPRouteList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []HTTPRoute `json:"items"`
}
func (in *HTTPRouteList) DeepCopy() *HTTPRouteList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteList.
func (in *HTTPRouteList) DeepCopyInto(out *HTTPRouteList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *HTTPRouteList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
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 HTTPRouteMatch = v1.HTTPRouteMatch
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 HTTPRouteRule = v1.HTTPRouteRule
HTTPRouteSpec defines the desired state of HTTPRoute +k8s:deepcopy-gen=false
type HTTPRouteSpec = v1.HTTPRouteSpec
HTTPRouteStatus defines the observed state of HTTPRoute. +k8s:deepcopy-gen=false
type HTTPRouteStatus = v1.HTTPRouteStatus
HTTPRouteTimeouts defines timeouts that can be configured for an HTTPRoute. +k8s:deepcopy-gen=false
type HTTPRouteTimeouts = v1.HTTPRouteTimeouts
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 HTTPURLRewriteFilter = v1.HTTPURLRewriteFilter
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 HeaderMatchType = v1.HeaderMatchType
Hostname is the fully qualified domain name of a network host. This matches the RFC 1123 definition of a hostname with 2 notable exceptions:
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 Hostname = v1.Hostname
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 Kind = v1.Kind
Listener embodies the concept of a logical endpoint where a Gateway accepts network connections. +k8s:deepcopy-gen=false
type Listener = v1.Listener
ListenerConditionReason defines the set of reasons that explain why a particular Listener condition type has been raised. +k8s:deepcopy-gen=false
type ListenerConditionReason = v1.ListenerConditionReason
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 ListenerConditionType = v1.ListenerConditionType
ListenerStatus is the status associated with a Listener. +k8s:deepcopy-gen=false
type ListenerStatus = v1.ListenerStatus
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 LocalObjectReference = v1.LocalObjectReference
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 Namespace = v1.Namespace
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 ObjectName = v1.ObjectName
ParametersReference identifies an API object containing controller-specific configuration resource within the cluster. +k8s:deepcopy-gen=false
type ParametersReference = v1.ParametersReference
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 ParentReference = v1.ParentReference
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 PathMatchType = v1.PathMatchType
PortNumber defines a network port.
+kubebuilder:validation:Minimum=1 +kubebuilder:validation:Maximum=65535
type PortNumber = v1.PortNumber
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 PreciseHostname = v1.PreciseHostname
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 ProtocolType = v1.ProtocolType
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 QueryParamMatchType = v1.QueryParamMatchType
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.
type ReferenceGrant struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
// Spec defines the desired state of ReferenceGrant.
Spec ReferenceGrantSpec `json:"spec,omitempty"`
}
func (in *ReferenceGrant) DeepCopy() *ReferenceGrant
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReferenceGrant.
func (in *ReferenceGrant) DeepCopyInto(out *ReferenceGrant)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReferenceGrant) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
ReferenceGrantFrom describes trusted namespaces and kinds.
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"`
}
func (in *ReferenceGrantFrom) DeepCopy() *ReferenceGrantFrom
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReferenceGrantFrom.
func (in *ReferenceGrantFrom) DeepCopyInto(out *ReferenceGrantFrom)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+kubebuilder:object:root=true ReferenceGrantList contains a list of ReferenceGrant.
type ReferenceGrantList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []ReferenceGrant `json:"items"`
}
func (in *ReferenceGrantList) DeepCopy() *ReferenceGrantList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReferenceGrantList.
func (in *ReferenceGrantList) DeepCopyInto(out *ReferenceGrantList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *ReferenceGrantList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
ReferenceGrantSpec identifies a cross namespace relationship that is trusted for Gateway API.
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"`
}
func (in *ReferenceGrantSpec) DeepCopy() *ReferenceGrantSpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReferenceGrantSpec.
func (in *ReferenceGrantSpec) DeepCopyInto(out *ReferenceGrantSpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
ReferenceGrantTo describes what Kinds are allowed as targets of the references.
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"`
}
func (in *ReferenceGrantTo) DeepCopy() *ReferenceGrantTo
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReferenceGrantTo.
func (in *ReferenceGrantTo) DeepCopyInto(out *ReferenceGrantTo)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
RouteConditionReason is a reason for a route condition.
type RouteConditionReason = v1.RouteConditionReason
RouteConditionType is a type of condition for a route.
type RouteConditionType = v1.RouteConditionType
RouteGroupKind indicates the group and kind of a Route resource. +k8s:deepcopy-gen=false
type RouteGroupKind = v1.RouteGroupKind
RouteNamespaces indicate which namespaces Routes should be selected from. +k8s:deepcopy-gen=false
type RouteNamespaces = v1.RouteNamespaces
RouteParentStatus describes the status of a route with respect to an associated Parent. +k8s:deepcopy-gen=false
type RouteParentStatus = v1.RouteParentStatus
RouteStatus defines the common attributes that all Routes MUST include within their status. +k8s:deepcopy-gen=false
type RouteStatus = v1.RouteStatus
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 SecretObjectReference = v1.SecretObjectReference
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 SectionName = v1.SectionName
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
type TLSModeType = v1.TLSModeType
| Name | Synopsis |
|---|---|
| .. | |
| util | |
| validation | |
| validation | Package validation has functions for validating the correctness of api objects and explaining what's wrong with them when they're not valid. |