Documentation ¶
Overview ¶
Package v1alpha1 contains API Schema definitions for the networking.x-k8s.io API group. +kubebuilder:object:generate=true +groupName=networking.x-k8s.io
Index ¶
- Constants
- Variables
- func Resource(resource string) schema.GroupResource
- type AddressType
- type BackendPolicy
- type BackendPolicyConditionType
- type BackendPolicyList
- type BackendPolicySpec
- type BackendPolicyStatus
- type BackendRef
- type BackendTLSConfig
- type Gateway
- type GatewayAddress
- type GatewayAllowType
- type GatewayClass
- type GatewayClassConditionType
- type GatewayClassList
- type GatewayClassSpec
- type GatewayClassStatus
- type GatewayConditionReason
- type GatewayConditionType
- type GatewayList
- type GatewayReference
- type GatewaySpec
- type GatewayStatus
- type GatewayTLSConfig
- type HTTPHeaderMatch
- type HTTPPathMatch
- type HTTPRequestHeaderFilter
- type HTTPRequestMirrorFilter
- type HTTPRoute
- type HTTPRouteFilter
- type HTTPRouteFilterType
- type HTTPRouteForwardTo
- type HTTPRouteList
- type HTTPRouteMatch
- type HTTPRouteRule
- type HTTPRouteSpec
- type HTTPRouteStatus
- type HeaderMatchType
- type Hostname
- type Listener
- type ListenerConditionReason
- type ListenerConditionType
- type ListenerStatus
- type LocalObjectReference
- type PathMatchType
- type PortNumber
- type ProtocolType
- type RouteBindingSelector
- type RouteConditionType
- type RouteForwardTo
- type RouteGatewayStatus
- type RouteGateways
- type RouteNamespaces
- type RouteSelectType
- type RouteStatus
- type RouteTLSConfig
- type TCPRoute
- type TCPRouteList
- type TCPRouteMatch
- type TCPRouteRule
- type TCPRouteSpec
- type TCPRouteStatus
- type TLSModeType
- type TLSOverridePolicy
- type TLSRoute
- type TLSRouteList
- type TLSRouteMatch
- type TLSRouteOverrideType
- type TLSRouteRule
- type TLSRouteSpec
- type TLSRouteStatus
- type UDPRoute
- type UDPRouteList
- type UDPRouteMatch
- type UDPRouteRule
- type UDPRouteSpec
- type UDPRouteStatus
Constants ¶
const ( // GatewayConditionScheduled indicates whether the controller // managing the Gateway has scheduled the Gateway to the // underlying network infrastructure. // // Possible reasons for this condition to be false are: // // * "NotReconciled" // * "NoSuchGatewayClass" // * "NoResources" // // Controllers may raise this condition with other reasons, // but should prefer to use the reasons listed above to improve // interoperability. GatewayConditionScheduled GatewayConditionType = "Scheduled" // GatewayReasonNotReconciled is used when the Gateway is // not scheduled because it recently been created and no // controller has reconciled it yet. GatewayReasonNotReconciled GatewayConditionReason = "NotReconciled" // GatewayReasonNoSuchGatewayClass is used when the Gateway is // not scheduled because there is no controller that recognizes // the GatewayClassName. This reason should only be set by // a controller that has cluster-wide visibility of all the // installed GatewayClasses. GatewayReasonNoSuchGatewayClass GatewayConditionReason = "NoSuchGatewayClass" // GatewayReasonNoResources is used when the Gateway is // not scheduled because no infrastructure resources are // available for this Gateway. GatewayReasonNoResources GatewayConditionReason = "NoResources" )
const ( // GatewayConditionReady indicates whether the Gateway is able // to serve traffic. Note that this does not indicate that the // Gateway configuration is current or even complete (e.g. the // controller may still not have reconciled the latest version, // or some parts of the configuration could be missing). // // If both the "ListenersNotValid" and "ListenersNotReady" // reasons are true, the Gateway controller should prefer the // "ListenersNotValid" reason. // // Possible reasons for this condition to be false are: // // * "ListenersNotValid" // * "ListenersNotReady" // * "AddressNotAssigned" // // Controllers may raise this condition with other reasons, // but should prefer to use the reasons listed above to improve // interoperability.` GatewayConditionReady GatewayConditionType = "Ready" // GatewayReasonListenersNotValid is used when one or more // Listeners have an invalid or unsupported configuration // and cannot be configured on the Gateway. GatewayReasonListenersNotValid GatewayConditionReason = "ListenersNotValid" // GatewayReasonListenersNotReady is used when one or more // Listeners are not ready to serve traffic. GatewayReasonListenersNotReady GatewayConditionReason = "ListenersNotReady" // GatewayReasonAddressNotAssigned is used when the requested // address has not been assigned to the Gateway. This reason // can be used to express a range of circumstances, including // (but not limited to) IPAM address exhaustion, invalid // or unsupported address requests, or a named address not // being found. GatewayReasonAddressNotAssigned GatewayConditionReason = "AddressNotAssigned" )
const ( // ListenerConditionConflicted indicates that the controller // was unable to resolve conflicting specification requirements // for this Listener. If a Listener is conflicted, its network // port should not be configured on any network elements. // // Possible reasons for this condition to be true are: // // * "HostnameConflict" // * "ProtocolConflict" // * "RouteConflict" // // Controllers may raise this condition with other reasons, // but should prefer to use the reasons listed above to improve // interoperability. ListenerConditionConflicted ListenerConditionType = "Conflicted" // ListenerReasonHostnameConflict is used when the Listener conflicts with // hostnames in other Listeners. For example, this reason would be used when // multiple Listeners on the same port use "*" in the hostname field. ListenerReasonHostnameConflict ListenerConditionReason = "HostnameConflict" // ListenerReasonProtocolConflict is used when multiple // Listeners are specified with the same Listener port number, // but have conflicting protocol specifications. ListenerReasonProtocolConflict ListenerConditionReason = "ProtocolConflict" // ListenerReasonRouteConflict is used when the route // resources selected for this Listener conflict with other // specified properties of the Listener (e.g. Protocol). // For example, a Listener that specifies "UDP" as the protocol // but a route selector that resolves "TCPRoute" objects. ListenerReasonRouteConflict ListenerConditionReason = "RouteConflict" )
const ( // ListenerConditionDetached indicates that, even though // the listener is syntactically and semantically valid, the // controller is not able to configure it on the underlying // Gateway infrastructure. // // A Listener is specified as a logical requirement, but needs to be // configured on a network endpoint (i.e. address and port) by a // controller. The controller may be unable to attach the Listener // if it specifies an unsupported requirement, or prerequisite // resources are not available. // // Possible reasons for this condition to be true are: // // * "PortUnavailable" // * "UnsupportedExtension" // * "UnsupportedProtocol" // * "UnsupportedAddress" // // Controllers may raise this condition with other reasons, // but should prefer to use the reasons listed above to improve // interoperability. ListenerConditionDetached ListenerConditionType = "Detached" // requests a port that cannot be used on the Gateway. ListenerReasonPortUnavailable ListenerConditionReason = "PortUnavailable" // ListenerReasonUnsupportedExtension is used when the // controller detects that an implementation-specific Listener // extension is being requested, but is not able to support // the extension. ListenerReasonUnsupportedExtension ListenerConditionReason = "UnsupportedExtension" // ListenerReasonUnsupportedProtocol is used when the // Listener could not be attached to be Gateway because its // protocol type is not supported. ListenerReasonUnsupportedProtocol ListenerConditionReason = "UnsupportedProtocol" // ListenerReasonUnsupportedAddress is used when the Listener // could not be attached to the Gateway because the requested // address is not supported. ListenerReasonUnsupportedAddress ListenerConditionReason = "UnsupportedAddress" )
const ( // ListenerConditionResolvedRefs indicates whether the // controller was able to resolve all the object references // for the Listener. // // Possible reasons for this condition to be false are: // // * "DegradedRoutes" // * "InvalidCertificateRef" // * "InvalidRoutesRef" // // Controllers may raise this condition with other reasons, // but should prefer to use the reasons listed above to improve // interoperability. ListenerConditionResolvedRefs ListenerConditionType = "ResolvedRefs" // ListenerReasonDegradedRoutes indicates that not all of the routes // selected by this Listener could be configured. The specific reason // for the degraded route should be indicated in the route's // .Status.Conditions field. ListenerReasonDegradedRoutes ListenerConditionReason = "DegradedRoutes" // ListenerReasonInvalidCertificateRef is used when the // Listener has a TLS configuration with a TLS CertificateRef // that is invalid or cannot be resolved. ListenerReasonInvalidCertificateRef ListenerConditionReason = "InvalidCertificateRef" // ListenerReasonInvalidRoutesRef is used when the Listener's Routes // selector is invalid or cannot be resolved. Note that it is not // an error for this selector to not resolve any Routes, and the // "ResolvedRefs" status condition should not be raised in that case. ListenerReasonInvalidRoutesRef ListenerConditionReason = "InvalidRoutesRef" )
const ( // ListenerConditionReady indicates whether the Listener // has been configured on the Gateway. // // Possible reasons for this condition to be false are: // // * "Invalid" // * "Pending" // // Controllers may raise this condition with other reasons, // but should prefer to use the reasons listed above to improve // interoperability. ListenerConditionReady ListenerConditionType = "Ready" // ListenerReasonInvalid is used when the Listener is // syntactically or semantically invalid. ListenerReasonInvalid ListenerConditionReason = "Invalid" // ListenerReasonPending is used when the Listener is not // yet not online and ready to accept client traffic. ListenerReasonPending ListenerConditionReason = "Pending" )
const ( // GatewayClassConditionStatusAdmitted indicates that the GatewayClass // has been admitted by the controller set in the `spec.controller` // field. // // It defaults to False, and MUST be set by a controller when it sees // a GatewayClass using its controller string. // The status of this condition MUST be set to true if the controller will support // provisioning Gateways using this class. Otherwise, this status MUST be set to false. // If the status is set to false, the controller SHOULD set a Message and Reason as an // explanation. // GatewayClassNotAdmittedInvalidParameters is provided as an example Reason. GatewayClassConditionStatusAdmitted GatewayClassConditionType = "Admitted" // GatewayClassNotAdmittedInvalidParameters should be used as a Reason on the Admitted // condition if the parametersRef field is invalid, with more detail in the message. GatewayClassNotAdmittedInvalidParameters string = "InvalidParameters" // GatewayClasssNotAdmittedWaiting is the default Reason on a new GatewayClass. GatewayClasssNotAdmittedWaiting string = "Waiting" // GatewayClassFinalizerGatewaysExist should be added as a finalizer to the // GatewayClass whenever there are provisioned Gateways using a GatewayClass. GatewayClassFinalizerGatewaysExist = "gateway-exists-finalizer.networking.x-k8s.io" )
const ( // AnnotationAppProtocol defines the protocol a Gateway should use for // communication with a Kubernetes Service. This annotation must be present // on the BackendPolicy resource and the protocol will apply to all Service // ports that are selected by BackendPolicy.Spec.BackendRefs. If the // AppProtocol field is available, this annotation should not be used. The // AppProtocol field, when populated, takes precedence over this annotation. // The value of this annotation must be also be a valid value for the // AppProtocol field. // // Examples: // // - `networking.x-k8s.io/app-protocol: https` // - `networking.x-k8s.io/app-protocol: tls` AnnotationAppProtocol = "networking.x-k8s.io/app-protocol" )
const GroupName = "networking.x-k8s.io"
GroupName specifies the group name used to register the objects.
Variables ¶
var ( // localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes. SchemeBuilder runtime.SchemeBuilder // Depreciated: use Install instead AddToScheme = localSchemeBuilder.AddToScheme Install = localSchemeBuilder.AddToScheme )
var GroupVersion = v1.GroupVersion{Group: GroupName, Version: "v1alpha1"}
GroupVersion specifies the group and the version used to register the objects.
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"}
SchemeGroupVersion is group version used to register these objects Deprecated: use GroupVersion instead.
Functions ¶
func Resource ¶
func Resource(resource string) schema.GroupResource
Resource takes an unqualified resource and returns a Group qualified GroupResource
Types ¶
type AddressType ¶
type AddressType string
AddressType defines how a network address is represented as a text string. Valid AddressType values are:
* "IPAddress" * "NamedAddress"
+kubebuilder:validation:Enum=IPAddress;NamedAddress
const ( // IPAddressType 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). // // If the requested address is unsupported, the controller // should raise the "Detached" listener status condition on // the Gateway with the "UnsupportedAddress" reason. // // Support: Extended. IPAddressType AddressType = "IPAddress" // NamedAddressType is an address selected by name. The interpretation // of the name is dependent on the controller. If a NamedAddress is // requested but unsupported by an implementation, the controller // should raise the "Detached" listener status condition on the Gateway // with the "UnsupportedAddress" reason. // // Support: Implementation-specific. NamedAddressType AddressType = "NamedAddress" )
type BackendPolicy ¶
type BackendPolicy struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` Spec BackendPolicySpec `json:"spec,omitempty"` Status BackendPolicyStatus `json:"status,omitempty"` }
BackendPolicy defines policies associated with backends. For the purpose of this API, a backend is defined as any resource that a route can forward traffic to. A common example of a backend is a Service. Configuration that is implementation specific may be represented with similar implementation specific custom resources.
func (*BackendPolicy) DeepCopy ¶
func (in *BackendPolicy) DeepCopy() *BackendPolicy
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackendPolicy.
func (*BackendPolicy) DeepCopyInto ¶
func (in *BackendPolicy) DeepCopyInto(out *BackendPolicy)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*BackendPolicy) DeepCopyObject ¶
func (in *BackendPolicy) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type BackendPolicyConditionType ¶
type BackendPolicyConditionType string
BackendPolicyConditionType is a type of condition associated with a BackendPolicy.
const ( // ConditionNoSuchBackend indicates that one or more of the the specified // Backends does not exist. ConditionNoSuchBackend BackendPolicyConditionType = "NoSuchBackend" )
type BackendPolicyList ¶
type BackendPolicyList struct { metav1.TypeMeta `json:",inline"` metav1.ListMeta `json:"metadata,omitempty"` Items []BackendPolicy `json:"items"` }
BackendPolicyList contains a list of BackendPolicy
func (*BackendPolicyList) DeepCopy ¶
func (in *BackendPolicyList) DeepCopy() *BackendPolicyList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackendPolicyList.
func (*BackendPolicyList) DeepCopyInto ¶
func (in *BackendPolicyList) DeepCopyInto(out *BackendPolicyList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*BackendPolicyList) DeepCopyObject ¶
func (in *BackendPolicyList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type BackendPolicySpec ¶
type BackendPolicySpec struct { // BackendRefs define which backends this policy should be applied to. This // policy can only apply to backends within the same namespace. If more than // one BackendPolicy targets the same backend, precedence must be given to // the oldest BackendPolicy. // // Support: Core // +kubebuilder:validation:MaxItems=16 BackendRefs []BackendRef `json:"backendRefs"` // TLS is the TLS configuration for these backends. // // Support: Extended // +optional TLS *BackendTLSConfig `json:"tls,omitempty"` }
BackendPolicySpec defines desired policy for a backend.
func (*BackendPolicySpec) DeepCopy ¶
func (in *BackendPolicySpec) DeepCopy() *BackendPolicySpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackendPolicySpec.
func (*BackendPolicySpec) DeepCopyInto ¶
func (in *BackendPolicySpec) DeepCopyInto(out *BackendPolicySpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type BackendPolicyStatus ¶
type BackendPolicyStatus struct { // Conditions describe the current conditions of the BackendPolicy. // // +listType=map // +listMapKey=type // +kubebuilder:validation:MaxItems=8 Conditions []metav1.Condition `json:"conditions,omitempty"` }
BackendPolicyStatus defines the observed state of BackendPolicy. Conditions that are related to a specific Route or Gateway should be placed on the Route(s) using backends configured by this BackendPolicy.
func (*BackendPolicyStatus) DeepCopy ¶
func (in *BackendPolicyStatus) DeepCopy() *BackendPolicyStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackendPolicyStatus.
func (*BackendPolicyStatus) DeepCopyInto ¶
func (in *BackendPolicyStatus) DeepCopyInto(out *BackendPolicyStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type BackendRef ¶
type BackendRef struct { // Group is the group of the referent. // +kubebuilder:validation:MaxLength=253 Group string `json:"group"` // Kind is the kind of the referent. // +kubebuilder:validation:MaxLength=253 Kind string `json:"kind,omitempty"` // Name is the name of the referent. // +kubebuilder:validation:MaxLength=253 Name string `json:"name"` // Port is the port of the referent. If unspecified, this policy applies to // all ports on the backend. // +optional Port *PortNumber `json:"port,omitempty"` }
BackendRef identifies an API object within a known namespace that defaults group to core and resource to services if unspecified.
func (*BackendRef) DeepCopy ¶
func (in *BackendRef) DeepCopy() *BackendRef
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackendRef.
func (*BackendRef) DeepCopyInto ¶
func (in *BackendRef) DeepCopyInto(out *BackendRef)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type BackendTLSConfig ¶
type BackendTLSConfig struct { // CertificateAuthorityRef is a reference to a resource that includes // trusted CA certificates for the associated backends. If an entry in this // list omits or specifies the empty string for both the group and the // resource, the resource defaults to "secrets". An implementation may // support other resources (for example, resource "mycertificates" in group // "networking.acme.io"). // // When stored in a Secret, certificates must be PEM encoded and specified // within the "ca.crt" data field of the Secret. Multiple certificates can // be specified, concatenated by new lines. // // Support: Extended // // +optional CertificateAuthorityRef *LocalObjectReference `json:"certificateAuthorityRef,omitempty"` // Options are a list of key/value pairs to give extended options to the // provider. // // Support: Implementation-specific. // +optional Options map[string]string `json:"options,omitempty"` }
BackendTLSConfig describes TLS configuration for a backend.
func (*BackendTLSConfig) DeepCopy ¶
func (in *BackendTLSConfig) DeepCopy() *BackendTLSConfig
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BackendTLSConfig.
func (*BackendTLSConfig) DeepCopyInto ¶
func (in *BackendTLSConfig) DeepCopyInto(out *BackendTLSConfig)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type Gateway ¶
type Gateway struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` Spec GatewaySpec `json:"spec,omitempty"` // +kubebuilder:default={conditions: {{type: "Scheduled", status: "False", reason:"NotReconciled", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}}} Status GatewayStatus `json:"status,omitempty"` }
Gateway represents an instantiation of a service-traffic handling infrastructure by binding Listeners to a set of IP addresses.
Implementations should add the `gateway-exists-finalizer.networking.x-k8s.io` finalizer on the associated GatewayClass whenever Gateway(s) is running. This ensures that a GatewayClass associated with a Gateway(s) is not deleted while in use.
func (*Gateway) DeepCopy ¶
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Gateway.
func (*Gateway) DeepCopyInto ¶
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*Gateway) DeepCopyObject ¶
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type GatewayAddress ¶
type GatewayAddress struct { // Type of the Address. This is either "IPAddress" or "NamedAddress". // // Support: Extended // // +kubebuilder:default=IPAddress Type AddressType `json:"type,omitempty"` // Value. Examples: "1.2.3.4", "128::1", "my-ip-address". Validity of the // values will depend on `Type` and support by the controller. // // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 Value string `json:"value"` }
GatewayAddress describes an address that can be bound to a Gateway.
func (*GatewayAddress) DeepCopy ¶
func (in *GatewayAddress) DeepCopy() *GatewayAddress
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayAddress.
func (*GatewayAddress) DeepCopyInto ¶
func (in *GatewayAddress) DeepCopyInto(out *GatewayAddress)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type GatewayAllowType ¶
type GatewayAllowType string
GatewayAllowType specifies which Gateways should be allowed to use a Route.
const ( // GatewayAllowAll indicates that all Gateways will be able to use this // route. GatewayAllowAll GatewayAllowType = "All" // GatewayAllowFromList indicates that only Gateways that have been // specified in GatewayRefs will be able to use this route. GatewayAllowFromList GatewayAllowType = "FromList" // GatewayAllowSameNamespace indicates that only Gateways within the same // namespace will be able to use this route. GatewayAllowSameNamespace GatewayAllowType = "SameNamespace" )
type GatewayClass ¶
type GatewayClass struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` // Spec for this GatewayClass. Spec GatewayClassSpec `json:"spec,omitempty"` // Status of the GatewayClass. // +kubebuilder:default={conditions: {{type: "InvalidParameters", status: "Unknown", message: "Waiting for controller", reason: "Waiting", lastTransitionTime: "1970-01-01T00:00:00Z"}}} Status GatewayClassStatus `json:"status,omitempty"` }
GatewayClass describes a class of Gateways available to the user for creating Gateway resources.
GatewayClass is a Cluster level resource.
Support: Core.
func (*GatewayClass) DeepCopy ¶
func (in *GatewayClass) DeepCopy() *GatewayClass
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayClass.
func (*GatewayClass) DeepCopyInto ¶
func (in *GatewayClass) DeepCopyInto(out *GatewayClass)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*GatewayClass) DeepCopyObject ¶
func (in *GatewayClass) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type GatewayClassConditionType ¶
type GatewayClassConditionType string
GatewayClassConditionType is the type of status conditions. This type should be used with the GatewayClassStatus.Conditions field.
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 (*GatewayClassList) DeepCopy ¶
func (in *GatewayClassList) DeepCopy() *GatewayClassList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayClassList.
func (*GatewayClassList) DeepCopyInto ¶
func (in *GatewayClassList) DeepCopyInto(out *GatewayClassList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*GatewayClassList) DeepCopyObject ¶
func (in *GatewayClassList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type GatewayClassSpec ¶
type GatewayClassSpec struct { // Controller is a domain/path string that indicates the // controller that is managing Gateways of this class. // // Example: "acme.io/gateway-controller". // // This field is not mutable and cannot be empty. // // The format of this field is DOMAIN "/" PATH, where DOMAIN // and PATH are valid Kubernetes names // (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names). // // Support: Core // // +kubebuilder:validation:MaxLength=253 Controller string `json:"controller"` // ParametersRef is a controller-specific resource containing the // configuration parameters corresponding to this class. This is optional if // the controller does not require any additional configuration. // // Parameters resources are implementation specific custom resources. These // resources must be cluster-scoped. // // If the referent cannot be found, the GatewayClass's "InvalidParameters" // status condition will be true. // // Support: Custom // // +optional ParametersRef *LocalObjectReference `json:"parametersRef,omitempty"` }
GatewayClassSpec reflects the configuration of a class of Gateways.
func (*GatewayClassSpec) DeepCopy ¶
func (in *GatewayClassSpec) DeepCopy() *GatewayClassSpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayClassSpec.
func (*GatewayClassSpec) DeepCopyInto ¶
func (in *GatewayClassSpec) DeepCopyInto(out *GatewayClassSpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type GatewayClassStatus ¶
type GatewayClassStatus struct { // Conditions is the current status from the controller for // this GatewayClass. // // +listType=map // +listMapKey=type // +kubebuilder:validation:MaxItems=8 // +kubebuilder:default={{type: "Admitted", status: "False", message: "Waiting for controller", reason: "Waiting", lastTransitionTime: "1970-01-01T00:00:00Z"}} Conditions []metav1.Condition `json:"conditions,omitempty"` }
GatewayClassStatus is the current status for the GatewayClass.
func (*GatewayClassStatus) DeepCopy ¶
func (in *GatewayClassStatus) DeepCopy() *GatewayClassStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayClassStatus.
func (*GatewayClassStatus) DeepCopyInto ¶
func (in *GatewayClassStatus) DeepCopyInto(out *GatewayClassStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type GatewayConditionReason ¶
type GatewayConditionReason string
GatewayConditionReason defines the set of reasons that explain why a particular Gateway condition type has been raised.
type GatewayConditionType ¶
type GatewayConditionType string
GatewayConditionType is a type of condition associated with a Gateway. This type should be used with the GatewayStatus.Conditions field.
type GatewayList ¶
type GatewayList struct { metav1.TypeMeta `json:",inline"` metav1.ListMeta `json:"metadata,omitempty"` Items []Gateway `json:"items"` }
GatewayList contains a list of Gateway
func (*GatewayList) DeepCopy ¶
func (in *GatewayList) DeepCopy() *GatewayList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayList.
func (*GatewayList) DeepCopyInto ¶
func (in *GatewayList) DeepCopyInto(out *GatewayList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*GatewayList) DeepCopyObject ¶
func (in *GatewayList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type GatewayReference ¶
type GatewayReference struct { // Name is the name of the referent. // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 Name string `json:"name"` // Namespace is the namespace of the referent. // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 Namespace string `json:"namespace"` }
GatewayReference identifies a Gateway in a specified namespace.
func (*GatewayReference) DeepCopy ¶
func (in *GatewayReference) DeepCopy() *GatewayReference
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayReference.
func (*GatewayReference) DeepCopyInto ¶
func (in *GatewayReference) DeepCopyInto(out *GatewayReference)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type GatewaySpec ¶
type GatewaySpec struct { // GatewayClassName used for this Gateway. This is the name of a // GatewayClass resource. // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 GatewayClassName string `json:"gatewayClassName"` // Listeners associated with this Gateway. Listeners define // logical endpoints that are bound on this Gateway's addresses. // At least one Listener MUST be specified. // // An implementation MAY group Listeners by Port and then collapse each // group of Listeners into a single Listener if the implementation // determines that the Listeners in the group are "compatible". An // implementation MAY also group together and collapse compatible // Listeners belonging to different Gateways. // // For example, an implementation might consider Listeners to be // compatible with each other if all of the following conditions are // met: // // 1. Either each Listener within the group specifies the "HTTP" // Protocol or each Listener within the group specifies either // the "HTTPS" or "TLS" Protocol. // // 2. Each Listener within the group specifies a Hostname that is unique // within the group. // // 3. As a special case, one Listener within a group may omit Hostname, // in which case this Listener matches when no other Listener // matches. // // If the implementation does collapse compatible Listeners, the // hostname provided in the incoming client request MUST be // matched to a Listener to find the correct set of Routes. // The incoming hostname MUST be matched using the Hostname // field for each Listener in order of most to least specific. // That is, exact matches must be processed before wildcard // matches. // // If this field specifies multiple Listeners that have the same // Port value but are not compatible, the implementation must raise // a "Conflicted" condition in the Listener status. // // Support: Core // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=64 Listeners []Listener `json:"listeners"` // Addresses requested for this gateway. This is optional and // behavior can depend on the GatewayClass. If a value is set // in the spec and the requested address is invalid, the // GatewayClass MUST indicate this in the associated entry in // GatewayStatus.Addresses. // // If no Addresses are specified, the GatewayClass may // schedule the Gateway in an implementation-defined manner, // assigning an appropriate set of Addresses. // // The GatewayClass MUST bind all Listeners to every // GatewayAddress that it assigns to the Gateway. // // Support: Core // // +optional // +kubebuilder:validation:MaxItems=16 Addresses []GatewayAddress `json:"addresses,omitempty"` }
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.
func (*GatewaySpec) DeepCopy ¶
func (in *GatewaySpec) DeepCopy() *GatewaySpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewaySpec.
func (*GatewaySpec) DeepCopyInto ¶
func (in *GatewaySpec) DeepCopyInto(out *GatewaySpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type GatewayStatus ¶
type GatewayStatus struct { // Addresses lists the IP addresses that have actually been // bound to the Gateway. These addresses may differ from the // addresses in the Spec, e.g. if the Gateway automatically // assigns an address from a reserved pool. // // These addresses should all be of type "IPAddress". // // +optional // +kubebuilder:validation:MaxItems=16 Addresses []GatewayAddress `json:"addresses"` // Conditions describe the current conditions of the Gateway. // // Implementations should prefer to express Gateway conditions // using the `GatewayConditionType` and `GatewayConditionReason` // constants so that operators and tools can converge on a common // vocabulary to describe Gateway state. // // Known condition types are: // // * "Scheduled" // * "Ready" // // +listType=map // +listMapKey=type // +kubebuilder:validation:MaxItems=8 // +kubebuilder:default={{type: "Scheduled", status: "False", reason:"NotReconciled", message:"Waiting for controller", lastTransitionTime: "1970-01-01T00:00:00Z"}} Conditions []metav1.Condition `json:"conditions,omitempty"` // Listeners provide status for each unique listener port defined in the Spec. // // +optional // +listType=map // +listMapKey=port // +kubebuilder:validation:MaxItems=64 Listeners []ListenerStatus `json:"listeners,omitempty"` }
GatewayStatus defines the observed state of Gateway.
func (*GatewayStatus) DeepCopy ¶
func (in *GatewayStatus) DeepCopy() *GatewayStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayStatus.
func (*GatewayStatus) DeepCopyInto ¶
func (in *GatewayStatus) DeepCopyInto(out *GatewayStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type GatewayTLSConfig ¶
type GatewayTLSConfig struct { // Mode defines the TLS behavior for the TLS session initiated by the client. // There are two possible modes: // - Terminate: The TLS session between the downstream client // and the Gateway is terminated at the Gateway. // - Passthrough: The TLS session is NOT terminated by the Gateway. This // implies that the Gateway can't decipher the TLS stream except for // the ClientHello message of the TLS protocol. // CertificateRef field is ignored in this mode. Mode TLSModeType `json:"mode,omitempty"` // CertificateRef is the reference to Kubernetes object that // contain a TLS certificate and private key. // This certificate MUST be used for TLS handshakes for the domain // this GatewayTLSConfig is associated with. // If an entry in this list omits or specifies the empty // string for both the group and the resource, the resource defaults to "secrets". // An implementation may support other resources (for example, resource // "mycertificates" in group "networking.acme.io"). // Support: Core (Kubernetes Secrets) // Support: Implementation-specific (Other resource types) // // +optional CertificateRef LocalObjectReference `json:"certificateRef,omitempty"` // RouteOverride dictates if TLS settings can be configured // via Routes or not. // // CertificateRef must be defined even if `routeOverride.certificate` is // set to 'Allow' as it will be used as the default certificate for the // listener. // // +kubebuilder:default={certificate:Deny} RouteOverride TLSOverridePolicy `json:"routeOverride,omitempty"` // Options are a list of key/value pairs to give extended options // to the provider. // // There variation among providers as to how ciphersuites are // expressed. If there is a common subset for expressing ciphers // then it will make sense to loft that as a core API // construct. // // Support: Implementation-specific. // // +optional Options map[string]string `json:"options"` }
GatewayTLSConfig describes a TLS configuration.
References - nginx: https://nginx.org/en/docs/http/configuring_https_servers.html - envoy: https://www.envoyproxy.io/docs/envoy/latest/api-v2/api/v2/auth/cert.proto - haproxy: https://www.haproxy.com/documentation/aloha/9-5/traffic-management/lb-layer7/tls/ - gcp: https://cloud.google.com/load-balancing/docs/use-ssl-policies#creating_an_ssl_policy_with_a_custom_profile - aws: https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies - azure: https://docs.microsoft.com/en-us/azure/app-service/configure-ssl-bindings#enforce-tls-1112
func (*GatewayTLSConfig) DeepCopy ¶
func (in *GatewayTLSConfig) DeepCopy() *GatewayTLSConfig
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new GatewayTLSConfig.
func (*GatewayTLSConfig) DeepCopyInto ¶
func (in *GatewayTLSConfig) DeepCopyInto(out *GatewayTLSConfig)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPHeaderMatch ¶
type HTTPHeaderMatch struct { // Type specifies how to match against the value of the header. // // Support: core (Exact) // Support: custom (RegularExpression, ImplementationSpecific) // // Since RegularExpression PathType has custom conformance, implementations // can support POSIX, PCRE or any other dialects of regular expressions. // Please read the implementation's documentation to determine the supported // dialect. // // HTTP Header name matching MUST be case-insensitive (RFC 2616 - section 4.2). // // +kubebuilder:default=Exact Type HeaderMatchType `json:"type,omitempty"` // Values is a map of HTTP Headers to be matched. // It MUST contain at least one entry. // // The HTTP header field name to match is the map key, and the // value of the HTTP header is the map value. HTTP header field name matching // MUST be case-insensitive. // // Multiple match values are ANDed together, meaning, a request // must match all the specified headers to select the route. Values map[string]string `json:"values"` }
HTTPHeaderMatch describes how to select a HTTP route by matching HTTP request headers.
func (*HTTPHeaderMatch) DeepCopy ¶
func (in *HTTPHeaderMatch) DeepCopy() *HTTPHeaderMatch
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPHeaderMatch.
func (*HTTPHeaderMatch) DeepCopyInto ¶
func (in *HTTPHeaderMatch) DeepCopyInto(out *HTTPHeaderMatch)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPPathMatch ¶
type HTTPPathMatch struct { // Type specifies how to match against the path Value. // // Support: core (Exact, Prefix) // Support: custom (RegularExpression, ImplementationSpecific) // // Since RegularExpression PathType has custom conformance, implementations // can support POSIX, PCRE or any other dialects of regular expressions. // Please read the implementation's documentation to determine the supported // dialect. // // +kubebuilder:default=Prefix Type PathMatchType `json:"type,omitempty"` // Value of the HTTP path to match against. // // +kubebuilder:validation:MinLength=1 Value string `json:"value"` }
HTTPPathMatch describes how to select a HTTP route by matching the HTTP request path.
func (*HTTPPathMatch) DeepCopy ¶
func (in *HTTPPathMatch) DeepCopy() *HTTPPathMatch
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPPathMatch.
func (*HTTPPathMatch) DeepCopyInto ¶
func (in *HTTPPathMatch) DeepCopyInto(out *HTTPPathMatch)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPRequestHeaderFilter ¶
type HTTPRequestHeaderFilter struct { // Add adds the given header (name, value) to the request // before the action. // // Input: // GET /foo HTTP/1.1 // // Config: // add: {"my-header": "foo"} // // Output: // GET /foo HTTP/1.1 // my-header: foo // // Support: Extended // +optional Add map[string]string `json:"add,omitempty"` // Remove the given header(s) from the HTTP request before the // action. The value of RemoveHeader is a list of HTTP header // names. Note that the header names are case-insensitive // [RFC-2616 4.2]. // // Input: // GET /foo HTTP/1.1 // My-Header1: ABC // My-Header2: DEF // My-Header2: GHI // // Config: // remove: ["my-header1", "my-header3"] // // Output: // GET /foo HTTP/1.1 // My-Header2: DEF // // Support: Extended // +optional // +kubebuilder:validation:MaxItems=16 Remove []string `json:"remove,omitempty"` }
HTTPRequestHeaderFilter defines configuration for the RequestHeaderModifier filter.
func (*HTTPRequestHeaderFilter) DeepCopy ¶
func (in *HTTPRequestHeaderFilter) DeepCopy() *HTTPRequestHeaderFilter
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRequestHeaderFilter.
func (*HTTPRequestHeaderFilter) DeepCopyInto ¶
func (in *HTTPRequestHeaderFilter) DeepCopyInto(out *HTTPRequestHeaderFilter)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPRequestMirrorFilter ¶
type HTTPRequestMirrorFilter struct { // ServiceName refers to the name of the Service to mirror matched requests // to. When specified, this takes the place of BackendRef. If both // BackendRef and ServiceName are specified, ServiceName will be given // precedence. // // If the referent cannot be found, the rule is not included in the route. // The controller should raise the "ResolvedRefs" condition on the Gateway // with the "DegradedRoutes" reason. The gateway status for this route should // be updated with a condition that describes the error more specifically. // // Support: Core // // +optional // +kubebuilder:validation:MaxLength=253 ServiceName *string `json:"serviceName,omitempty"` // BackendRef is a local object reference to mirror matched requests to. If // both BackendRef and ServiceName are specified, ServiceName will be given // precedence. // // If the referent cannot be found, the rule is not included in the route. // The controller should raise the "ResolvedRefs" condition on the Gateway // with the "DegradedRoutes" reason. The gateway status for this route should // be updated with a condition that describes the error more specifically. // // Support: Custom // // +optional BackendRef *LocalObjectReference `json:"backendRef,omitempty"` // Port specifies the destination port number to use for the // backend referenced by the ServiceName or BackendRef field. // Port PortNumber `json:"port"` }
HTTPRequestMirrorFilter defines configuration for the RequestMirror filter.
func (*HTTPRequestMirrorFilter) DeepCopy ¶
func (in *HTTPRequestMirrorFilter) DeepCopy() *HTTPRequestMirrorFilter
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRequestMirrorFilter.
func (*HTTPRequestMirrorFilter) DeepCopyInto ¶
func (in *HTTPRequestMirrorFilter) DeepCopyInto(out *HTTPRequestMirrorFilter)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPRoute ¶
type HTTPRoute struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` Spec HTTPRouteSpec `json:"spec,omitempty"` Status HTTPRouteStatus `json:"status,omitempty"` }
HTTPRoute is the Schema for the HTTPRoute resource.
func (*HTTPRoute) DeepCopy ¶
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRoute.
func (*HTTPRoute) DeepCopyInto ¶
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*HTTPRoute) DeepCopyObject ¶
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type HTTPRouteFilter ¶
type HTTPRouteFilter struct { // Type identifies the type of filter to apply. As with other API fields, // types are classified into three conformance levels: // // - Core: Filter types and their corresponding configuration defined by // "Support: Core" in this package, e.g. "RequestHeaderModifier". All // implementations must support core filters. // // - Extended: Filter types and their corresponding configuration defined by // "Support: Extended" in this package, e.g. "RequestMirror". Implementers // are encouraged to support extended filters. // // - Custom: Filters that are defined and supported by specific vendors. // In the future, filters showing convergence in behavior across multiple // implementations will be considered for inclusion in extended or core // conformance levels. Filter-specific configuration for such filters // is specified using the ExtensionRef field. `Type` should be set to // "ExtensionRef" for custom filters. // // Implementers are encouraged to define custom implementation types to // extend the core API with implementation-specific behavior. // // +unionDiscriminator Type HTTPRouteFilterType `json:"type"` // RequestHeaderModifier defines a schema for a filter that modifies request // headers. // // Support: Core // // +optional RequestHeaderModifier *HTTPRequestHeaderFilter `json:"requestHeaderModifier,omitempty"` // RequestMirror defines a schema for a filter that mirrors requests. // // Support: Extended // // +optional RequestMirror *HTTPRequestMirrorFilter `json:"requestMirror,omitempty"` // ExtensionRef is an optional, implementation-specific extension to the // "filter" behavior. For example, resource "myroutefilter" in group // "networking.acme.io"). ExtensionRef MUST NOT be used for core and // extended filters. // // Support: Implementation-specific // // +optional ExtensionRef *LocalObjectReference `json:"extensionRef,omitempty"` }
HTTPRouteFilter defines additional processing steps that must be completed during the request or response lifecycle. HTTPRouteFilters are meant as an extension point to express additional 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. TODO(hbagdi): re-render CRDs once controller-tools supports union tags: - https://github.com/kubernetes-sigs/controller-tools/pull/298 - https://github.com/kubernetes-sigs/controller-tools/issues/461 +union
func (*HTTPRouteFilter) DeepCopy ¶
func (in *HTTPRouteFilter) DeepCopy() *HTTPRouteFilter
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteFilter.
func (*HTTPRouteFilter) DeepCopyInto ¶
func (in *HTTPRouteFilter) DeepCopyInto(out *HTTPRouteFilter)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPRouteFilterType ¶
type HTTPRouteFilterType string
HTTPRouteFilterType identifies a type of HTTPRoute filter. +kubebuilder:validation:Enum=RequestHeaderModifier;RequestMirror;ExtensionRef
const ( // HTTPRouteFilterRequestHeaderModifier can be used to add or remove an HTTP // header from an HTTP request before it is sent to the upstream target. // // Support in HTTPRouteRule: Core // Support in HTTPRouteForwardTo: Extended HTTPRouteFilterRequestHeaderModifier HTTPRouteFilterType = "RequestHeaderModifier" // HTTPRouteFilterRequestMirror can be used to mirror HTTP requests to a // different backend. The responses from this backend MUST be ignored by // the Gateway. // // Support in HTTPRouteRule: Extended // Support in HTTPRouteForwardTo: Extended HTTPRouteFilterRequestMirror HTTPRouteFilterType = "RequestMirror" // HTTPRouteFilterExtensionRef should be used for configuring custom // HTTP filters. // // Support in HTTPRouteRule: Custom // Support in HTTPRouteForwardTo: Custom HTTPRouteFilterExtensionRef HTTPRouteFilterType = "ExtensionRef" )
type HTTPRouteForwardTo ¶
type HTTPRouteForwardTo struct { // ServiceName refers to the name of the Service to forward matched requests // to. When specified, this takes the place of BackendRef. If both // BackendRef and ServiceName are specified, ServiceName will be given // precedence. // // If the referent cannot be found, the route must be dropped // from the Gateway. The controller should raise the "ResolvedRefs" // condition on the Gateway with the "DroppedRoutes" reason. // The gateway status for this route should be updated with a // condition that describes the error more specifically. // // The protocol to use should be specified with the AppProtocol field on Service // resources. This field was introduced in Kubernetes 1.18. If using an earlier version // of Kubernetes, a `networking.x-k8s.io/app-protocol` annotation on the // BackendPolicy resource may be used to define the protocol. If the // AppProtocol field is available, this annotation should not be used. The // AppProtocol field, when populated, takes precedence over the annotation // in the BackendPolicy resource. For custom backends, it is encouraged to // add a semantically-equivalent field in the Custom Resource Definition. // // Support: Core // // +optional // +kubebuilder:validation:MaxLength=253 ServiceName *string `json:"serviceName,omitempty"` // BackendRef is a reference to a backend to forward matched requests to. If // both BackendRef and ServiceName are specified, ServiceName will be given // precedence. // // If the referent cannot be found, the route must be dropped // from the Gateway. The controller should raise the "ResolvedRefs" // condition on the Gateway with the "DroppedRoutes" reason. // The gateway status for this route should be updated with a // condition that describes the error more specifically. // // Support: Custom // // +optional BackendRef *LocalObjectReference `json:"backendRef,omitempty"` // Port specifies the destination port number to use for the // backend referenced by the ServiceName or BackendRef field. // // Support: Core // Port PortNumber `json:"port"` // Weight specifies the proportion of HTTP requests forwarded to the backend // referenced by the ServiceName or BackendRef field. This is computed as // weight/(sum of all weights in this ForwardTo list). For non-zero values, // there may be some epsilon from the exact proportion defined here // depending on the precision an implementation supports. Weight is not a // percentage and the sum of weights does not need to equal 100. // // If only one backend is specified and it has a weight greater than 0, 100% // of the traffic is forwarded to that backend. If weight is set to 0, no // traffic should be forwarded for this entry. If unspecified, weight // defaults to 1. // // Support: Core // // +kubebuilder:default=1 // +kubebuilder:validation:Minimum=0 // +kubebuilder:validation:Maximum=1000000 Weight int32 `json:"weight,omitempty"` // Filters defined at this-level should be executed if and only if the // request is being forwarded to the backend defined here. // // Support: Custom (For broader support of filters, use the Filters field // in HTTPRouteRule.) // // +optional // +kubebuilder:validation:MaxItems=16 Filters []HTTPRouteFilter `json:"filters,omitempty"` }
HTTPRouteForwardTo defines how a HTTPRoute should forward a request.
func (*HTTPRouteForwardTo) DeepCopy ¶
func (in *HTTPRouteForwardTo) DeepCopy() *HTTPRouteForwardTo
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteForwardTo.
func (*HTTPRouteForwardTo) DeepCopyInto ¶
func (in *HTTPRouteForwardTo) DeepCopyInto(out *HTTPRouteForwardTo)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
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 (*HTTPRouteList) DeepCopy ¶
func (in *HTTPRouteList) DeepCopy() *HTTPRouteList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteList.
func (*HTTPRouteList) DeepCopyInto ¶
func (in *HTTPRouteList) DeepCopyInto(out *HTTPRouteList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*HTTPRouteList) DeepCopyObject ¶
func (in *HTTPRouteList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type HTTPRouteMatch ¶
type HTTPRouteMatch struct { // Path specifies a HTTP request path matcher. If this field is not // specified, a default prefix match on the "/" path is provided. // // +kubebuilder:default={type: "Prefix", value: "/"} Path HTTPPathMatch `json:"path,omitempty"` // Headers specifies a HTTP request header matcher. // // +optional Headers *HTTPHeaderMatch `json:"headers"` // ExtensionRef is an optional, implementation-specific extension to the // "match" behavior. For example, resource "myroutematcher" in group // "networking.acme.io". If the referent cannot be found, the rule is not // included in the route. The controller should raise the "ResolvedRefs" // condition on the Gateway with the "DegradedRoutes" reason. The gateway // status for this route should be updated with a condition that describes // the error more specifically. // // Support: custom // // +optional ExtensionRef *LocalObjectReference `json:"extensionRef,omitempty"` }
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: "1"` header:
``` match:
path: value: "/foo" headers: values: version: "1"
```
func (*HTTPRouteMatch) DeepCopy ¶
func (in *HTTPRouteMatch) DeepCopy() *HTTPRouteMatch
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteMatch.
func (*HTTPRouteMatch) DeepCopyInto ¶
func (in *HTTPRouteMatch) DeepCopyInto(out *HTTPRouteMatch)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPRouteRule ¶
type HTTPRouteRule struct { // Matches define conditions used for matching the rule against // incoming HTTP requests. // Each match is independent, i.e. this rule will be matched // if **any** one of the matches is satisfied. // // For example, take the following matches configuration: // // “` // matches: // - path: // value: "/foo" // headers: // values: // version: "2" // - path: // value: "/v2/foo" // “` // // For a request to match against this rule, a request should satisfy // EITHER of the two conditions: // // - path prefixed with `/foo` AND contains the header `version: "2"` // - path prefix of `/v2/foo` // // See the documentation for HTTPRouteMatch on how to specify multiple // match conditions that should be ANDed together. // // If no matches are specified, the default is a prefix // path match on "/", which has the effect of matching every // HTTP request. // // // A client request may match multiple HTTP route rules. Matching precedence // MUST be determined in order of the following criteria, continuing on ties: // * The longest matching hostname. // * The longest matching path. // * The largest number of header matches // * The oldest Route based on creation timestamp. For example, a Route with // a creation timestamp of "2020-09-08 01:02:03" is given precedence over // a Route with a creation timestamp of "2020-09-08 01:02:04". // * The Route appearing first in alphabetical order (namespace/name) for // example, foo/bar is given precedence over foo/baz. // +kubebuilder:default={{path:{ type: "Prefix", value: "/"}}} // +kubebuilder:validation:MaxItems=8 Matches []HTTPRouteMatch `json:"matches,omitempty"` // Filters define the filters that are applied to requests that match // this rule. // // The effects of ordering of multiple behaviors are currently unspecified. // This can change in the future based on feedback during the alpha stage. // // Conformance-levels at this level are defined based on the type of filter: // - ALL core filters MUST be supported by all implementations. // - Implementers are encouraged to support extended filters. // - Implementation-specific custom filters have no API guarantees across // implementations. // // Specifying a core filter multiple times has unspecified or custom conformance. // // Support: core // // +optional // +kubebuilder:validation:MaxItems=16 Filters []HTTPRouteFilter `json:"filters,omitempty"` // ForwardTo defines the backend(s) where matching requests should be sent. // If unspecified, the rule performs no forwarding. If unspecified and no // filters are specified that would result in a response being sent, a 503 // error code is returned. // // +optional // +kubebuilder:validation:MaxItems=4 ForwardTo []HTTPRouteForwardTo `json:"forwardTo,omitempty"` }
HTTPRouteRule defines semantics for matching an HTTP request based on conditions, optionally executing additional processing steps, and forwarding the request to an API object.
func (*HTTPRouteRule) DeepCopy ¶
func (in *HTTPRouteRule) DeepCopy() *HTTPRouteRule
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteRule.
func (*HTTPRouteRule) DeepCopyInto ¶
func (in *HTTPRouteRule) DeepCopyInto(out *HTTPRouteRule)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPRouteSpec ¶
type HTTPRouteSpec struct { // Gateways defines which Gateways can use this Route. // +kubebuilder:default={allow: "SameNamespace"} Gateways RouteGateways `json:"gateways,omitempty"` // Hostnames defines a set of hostname that should match against // the HTTP Host header to select a HTTPRoute to process the request. // Hostname is the fully qualified domain name of a network host, // as defined by RFC 3986. Note the following deviations from the // "host" part of the URI as defined in the RFC: // // 1. IPs are not allowed. // 2. The `:` delimiter is not respected because ports are not allowed. // // Incoming requests are matched against the hostnames before the // HTTPRoute rules. If no hostname is specified, traffic is routed // based on the HTTPRouteRules. // // 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"). // The wildcard character '*' must appear by itself as the first DNS // label and matches only a single label. // You cannot have a wildcard label by itself (e.g. Host == "*"). // Requests will be matched against the Host field in the following order: // 1. If Host is precise, the request matches this rule if // the http host header is equal to Host. // 2. If Host is a wildcard, then the request matches this rule if // the http host header is to equal to the suffix // (removing the first label) of the wildcard rule. // // Support: Core // // +optional // +kubebuilder:validation:MaxItems=16 Hostnames []Hostname `json:"hostnames,omitempty"` // TLS defines the TLS certificate to use for Hostnames defined in this // Route. This configuration only takes effect if the AllowRouteOverride // field is set to true in the associated Gateway resource. // // Collisions can happen if multiple HTTPRoutes define a TLS certificate // for the same hostname. In such a case, conflict resolution guiding // principles apply, specificallly, if hostnames are same and two different // certificates are specified then the certificate in the // oldest resource wins. // // Please note that HTTP Route-selection takes place after the // TLS Handshake (ClientHello). Due to this, TLS certificate defined // here will take precedence even if the request has the potential to // match multiple routes (in case multiple HTTPRoutes share the same // hostname). // // Support: Core // // +optional TLS *RouteTLSConfig `json:"tls,omitempty"` // Rules are a list of HTTP matchers, filters and actions. // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=16 Rules []HTTPRouteRule `json:"rules"` }
HTTPRouteSpec defines the desired state of HTTPRoute
func (*HTTPRouteSpec) DeepCopy ¶
func (in *HTTPRouteSpec) DeepCopy() *HTTPRouteSpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteSpec.
func (*HTTPRouteSpec) DeepCopyInto ¶
func (in *HTTPRouteSpec) DeepCopyInto(out *HTTPRouteSpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HTTPRouteStatus ¶
type HTTPRouteStatus struct {
RouteStatus `json:",inline"`
}
HTTPRouteStatus defines the observed state of HTTPRoute.
func (*HTTPRouteStatus) DeepCopy ¶
func (in *HTTPRouteStatus) DeepCopy() *HTTPRouteStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPRouteStatus.
func (*HTTPRouteStatus) DeepCopyInto ¶
func (in *HTTPRouteStatus) DeepCopyInto(out *HTTPRouteStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type HeaderMatchType ¶
type HeaderMatchType string
HeaderMatchType specifies the semantics of how HTTP header values should be compared. Valid HeaderMatchType values are:
* "Exact" * "RegularExpression" * "ImplementationSpecific"
+kubebuilder:validation:Enum=Exact;RegularExpression;ImplementationSpecific
const ( HeaderMatchExact HeaderMatchType = "Exact" HeaderMatchRegularExpression HeaderMatchType = "RegularExpression" HeaderMatchImplementationSpecific HeaderMatchType = "ImplementationSpecific" )
HeaderMatchType constants.
type Hostname ¶
type Hostname string
Hostname is used to specify a hostname that should be matched. +kubebuilder:validation:MinLength=1 +kubebuilder:validation:MaxLength=253
type Listener ¶
type Listener struct { // Hostname specifies the virtual hostname to match for protocol types that // define this concept. When unspecified or "*", all hostnames are matched. // This field can be omitted for protocols that don't require hostname based // matching. // // Hostname is the fully qualified domain name of a network host, as defined // by RFC 3986. Note the following deviations from the "host" part of the // URI as defined in the RFC: // // 1. IP literals are not allowed. // 2. The `:` delimiter is not respected because ports are not allowed. // // 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"). // The wildcard character '*' must appear by itself as the first DNS label // and matches only a single label. // // Support: Core // // +optional Hostname *Hostname `json:"hostname,omitempty"` // Port is the network port. Multiple listeners may use the // same port, subject to the Listener compatibility rules. // // Support: Core Port PortNumber `json:"port"` // Protocol specifies the network protocol this listener expects to receive. // The GatewayClass MUST apply the Hostname match appropriately for each // protocol: // // * For the "TLS" protocol, the Hostname match MUST be // applied to the [SNI](https://tools.ietf.org/html/rfc6066#section-3) // server name offered by the client. // * For the "HTTP" protocol, the Hostname match MUST be // applied to the host portion of the // [effective request URI](https://tools.ietf.org/html/rfc7230#section-5.5) // or the [:authority pseudo-header](https://tools.ietf.org/html/rfc7540#section-8.1.2.3) // * For the "HTTPS" protocol, the Hostname match MUST be // applied at both the TLS and HTTP protocol layers. // // Support: Core Protocol ProtocolType `json:"protocol"` // TLS is the TLS configuration for the Listener. This field // is required if the Protocol field is "HTTPS" or "TLS" and // ignored otherwise. // // The association of SNIs to Certificate defined in GatewayTLSConfig is // defined based on the Hostname field for this listener. // // The GatewayClass MUST use the longest matching SNI out of all // available certificates for any TLS handshake. // // Support: Core // // +optional TLS *GatewayTLSConfig `json:"tls,omitempty"` // Routes specifies a schema for associating routes with the // Listener using selectors. A Route is a resource capable of // servicing a request and allows a cluster operator to expose // a cluster resource (i.e. Service) by externally-reachable // URL, load-balance traffic and terminate SSL/TLS. Typically, // a route is a "HTTPRoute" or "TCPRoute" in group // "networking.x-k8s.io", however, an implementation may support // other types of resources. // // The Routes selector MUST select a set of objects that // are compatible with the application protocol specified in // the Protocol field. // // Although a client request may technically match multiple route rules, // only one rule may ultimately receive the request. Matching precedence // MUST be determined in order of the following criteria: // // * The most specific match. For example, the most specific HTTPRoute match // is determined by the longest matching combination of hostname and path. // * The oldest Route based on creation timestamp. For example, a Route with // a creation timestamp of "2020-09-08 01:02:03" is given precedence over // a Route with a creation timestamp of "2020-09-08 01:02:04". // * If everything else is equivalent, the Route appearing first in // alphabetical order (namespace/name) should be given precedence. For // example, foo/bar is given precedence over foo/baz. // // All valid portions of a Route selected by this field should be supported. // Invalid portions of a Route can be ignored (sometimes that will mean the // full Route). If a portion of a Route transitions from valid to invalid, // support for that portion of the Route should be dropped to ensure // consistency. For example, even if a filter specified by a Route is // invalid, the rest of the Route should still be supported. // // Support: Core Routes RouteBindingSelector `json:"routes"` }
Listener embodies the concept of a logical endpoint where a Gateway can accept network connections. Each listener in a Gateway must have a unique combination of Hostname, Port, and Protocol. This will be enforced by a validating webhook.
func (*Listener) DeepCopy ¶
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Listener.
func (*Listener) DeepCopyInto ¶
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type ListenerConditionReason ¶
type ListenerConditionReason string
ListenerConditionReason defines the set of reasons that explain why a particular Listener condition type has been raised.
type ListenerConditionType ¶
type ListenerConditionType string
ListenerConditionType is a type of condition associated with the listener. This type should be used with the ListenerStatus.Conditions field.
type ListenerStatus ¶
type ListenerStatus struct { // Port is the unique Listener port value for which this message is // reporting the status. Port PortNumber `json:"port"` // Protocol is the Listener protocol value for which this message is // reporting the status. Protocol ProtocolType `json:"protocol"` // Hostname is the Listener hostname value for which this message is // reporting the status. // +optional Hostname *Hostname `json:"hostname,omitempty"` // Conditions describe the current condition of this listener. // // +listType=map // +listMapKey=type // +kubebuilder:validation:MaxItems=8 Conditions []metav1.Condition `json:"conditions"` }
ListenerStatus is the status associated with a Listener.
func (*ListenerStatus) DeepCopy ¶
func (in *ListenerStatus) DeepCopy() *ListenerStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ListenerStatus.
func (*ListenerStatus) DeepCopyInto ¶
func (in *ListenerStatus) DeepCopyInto(out *ListenerStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type LocalObjectReference ¶
type LocalObjectReference struct { // Group is the group of the referent. // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 Group string `json:"group"` // Kind is kind of the referent. // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 Kind string `json:"kind"` // Name is the name of the referent. // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 Name string `json:"name"` }
LocalObjectReference identifies an API object within a known namespace.
func (*LocalObjectReference) DeepCopy ¶
func (in *LocalObjectReference) DeepCopy() *LocalObjectReference
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LocalObjectReference.
func (*LocalObjectReference) DeepCopyInto ¶
func (in *LocalObjectReference) DeepCopyInto(out *LocalObjectReference)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type PathMatchType ¶
type PathMatchType string
PathMatchType specifies the semantics of how HTTP paths should be compared. Valid PathMatchType values are:
* "Exact" * "Prefix" * "RegularExpression" * "ImplementationSpecific"
Prefix and Exact paths must be syntactically valid:
- Must begin with the '/' character
- Must not contain consecutive '/' characters (e.g. /foo///, //).
- For prefix paths, a trailing '/' character in the Path is ignored, e.g. /abc and /abc/ specify the same match.
+kubebuilder:validation:Enum=Exact;Prefix;RegularExpression;ImplementationSpecific
const ( PathMatchExact PathMatchType = "Exact" PathMatchPrefix PathMatchType = "Prefix" PathMatchRegularExpression PathMatchType = "RegularExpression" PathMatchImplementationSpecific PathMatchType = "ImplementationSpecific" )
PathMatchType constants.
type PortNumber ¶
type PortNumber int32
PortNumber defines a network port.
+kubebuilder:validation:Minimum=1 +kubebuilder:validation:Maximum=65535
type ProtocolType ¶
type ProtocolType string
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 should raise a "Detached" condition for the affected Listener with a reason of "UnsupportedProtocol".
Core ProtocolType values are:
* "HTTP" * "HTTPS" * "TLS" * "TCP" * "UDP"
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 custom conformance.
const ( // HTTPProtocolType accepts cleartext HTTP/1.1 sessions over TCP. HTTPProtocolType ProtocolType = "HTTP" // HTTPSProtocolType accepts HTTP/1.1 or HTTP/2 sessions over TLS. HTTPSProtocolType ProtocolType = "HTTPS" // TLSProtocolType accepts TLS sessions over TCP. TLSProtocolType ProtocolType = "TLS" // TCPProtocolType accepts TCP sessions. TCPProtocolType ProtocolType = "TCP" // UDPProtocolType accepts UDP packets. UDPProtocolType ProtocolType = "UDP" )
type RouteBindingSelector ¶
type RouteBindingSelector struct { // Namespaces indicates in which namespaces Routes should be selected // for this Gateway. This is restricted to the namespace of this Gateway by // default. // // Support: Core // +kubebuilder:default={from: "Same"} Namespaces *RouteNamespaces `json:"namespaces,omitempty"` // Selector specifies a set of route labels used for selecting // routes to associate with the Gateway. If RouteSelector is defined, // only routes matching the RouteSelector are associated with the Gateway. // An empty RouteSelector matches all routes. // // Support: Core // // +optional Selector metav1.LabelSelector `json:"selector,omitempty"` // Group is the group of the route resource to select. Omitting the value or specifying // the empty string indicates the networking.x-k8s.io API group. // For example, use the following to select an HTTPRoute: // // routes: // kind: HTTPRoute // // Otherwise, if an alternative API group is desired, specify the desired // group: // // routes: // group: acme.io // kind: FooRoute // // Support: Core // // +kubebuilder:default=networking.x-k8s.io // +kubebuilder:validation:MinLength=1 // +kubebuilder:validation:MaxLength=253 Group string `json:"group,omitempty"` // Kind is the kind of the route resource to select. // // Kind MUST correspond to kinds of routes that are compatible with the // application protocol specified in the Listener's Protocol field. // // If an implementation does not support or recognize this // resource type, it SHOULD raise a "ConditionInvalidRoutes" // condition for the affected Listener. // // Support: Core Kind string `json:"kind"` }
RouteBindingSelector defines a schema for associating routes with the Gateway. If Namespaces and Selector are defined, only routes matching both selectors are associated with the Gateway.
func (*RouteBindingSelector) DeepCopy ¶
func (in *RouteBindingSelector) DeepCopy() *RouteBindingSelector
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteBindingSelector.
func (*RouteBindingSelector) DeepCopyInto ¶
func (in *RouteBindingSelector) DeepCopyInto(out *RouteBindingSelector)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type RouteConditionType ¶
type RouteConditionType string
RouteConditionType is a type of condition for a route.
const ( // ConditionRouteAdmitted indicates whether the route has been admitted // or rejected by a Gateway, and why. ConditionRouteAdmitted RouteConditionType = "Admitted" )
type RouteForwardTo ¶
type RouteForwardTo struct { // ServiceName refers to the name of the Service to forward matched requests // to. When specified, this takes the place of BackendRef. If both // BackendRef and ServiceName are specified, ServiceName will be given // precedence. // // If the referent cannot be found, the rule is not included in the route. // The controller should raise the "ResolvedRefs" condition on the Gateway // with the "DegradedRoutes" reason. The gateway status for this route should // be updated with a condition that describes the error more specifically. // // The protocol to use is defined using AppProtocol field (introduced in // Kubernetes 1.18) in the Service resource. In the absence of the // AppProtocol field a `networking.x-k8s.io/app-protocol` annotation on the // BackendPolicy resource may be used to define the protocol. If the // AppProtocol field is available, this annotation should not be used. The // AppProtocol field, when populated, takes precedence over the annotation // in the BackendPolicy resource. For custom backends, it is encouraged to // add a semantically-equivalent field in the Custom Resource Definition. // // Support: Core // // +optional // +kubebuilder:validation:MaxLength=253 ServiceName *string `json:"serviceName,omitempty"` // BackendRef is a reference to a backend to forward matched requests to. If // both BackendRef and ServiceName are specified, ServiceName will be given // precedence. // // If the referent cannot be found, the rule is not included in the route. // The controller should raise the "ResolvedRefs" condition on the Gateway // with the "DegradedRoutes" reason. The gateway status for this route should // be updated with a condition that describes the error more specifically. // // // Support: Custom // // +optional BackendRef *LocalObjectReference `json:"backendRef,omitempty"` // Port specifies the destination port number to use for the // backend referenced by the ServiceName or BackendRef field. // // Support: Core Port PortNumber `json:"port"` // Weight specifies the proportion of HTTP requests forwarded to the backend // referenced by the ServiceName or BackendRef field. This is computed as // weight/(sum of all weights in this ForwardTo list). For non-zero values, // there may be some epsilon from the exact proportion defined here // depending on the precision an implementation supports. Weight is not a // percentage and the sum of weights does not need to equal 100. // // If only one backend is specified and it has a weight greater than 0, 100% // of the traffic is forwarded to that backend. If weight is set to 0, no // traffic should be forwarded for this entry. If unspecified, weight // defaults to 1. // // Support: Extended // // +kubebuilder:default=1 // +kubebuilder:validation:Minimum=0 // +kubebuilder:validation:Maximum=1000000 Weight int32 `json:"weight,omitempty"` }
RouteForwardTo defines how a Route should forward a request.
func (*RouteForwardTo) DeepCopy ¶
func (in *RouteForwardTo) DeepCopy() *RouteForwardTo
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteForwardTo.
func (*RouteForwardTo) DeepCopyInto ¶
func (in *RouteForwardTo) DeepCopyInto(out *RouteForwardTo)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type RouteGatewayStatus ¶
type RouteGatewayStatus struct { // GatewayRef is a reference to a Gateway object that is associated with // the route. GatewayRef GatewayReference `json:"gatewayRef"` // Conditions describes the status of the route with respect to the // Gateway. For example, the "Admitted" condition indicates whether the // route has been admitted or rejected by the Gateway, and why. Note // that the route's availability is also subject to the Gateway's own // status conditions and listener status. // // +listType=map // +listMapKey=type // +kubebuilder:validation:MaxItems=8 Conditions []metav1.Condition `json:"conditions,omitempty"` }
RouteGatewayStatus describes the status of a route with respect to an associated Gateway.
func (*RouteGatewayStatus) DeepCopy ¶
func (in *RouteGatewayStatus) DeepCopy() *RouteGatewayStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteGatewayStatus.
func (*RouteGatewayStatus) DeepCopyInto ¶
func (in *RouteGatewayStatus) DeepCopyInto(out *RouteGatewayStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type RouteGateways ¶
type RouteGateways struct { // Allow indicates which Gateways will be allowed to use this route. // Possible values are: // * All: Gateways in any namespace can use this route. // * FromList: Only Gateways specified in GatewayRefs may use this route. // * SameNamespace: Only Gateways in the same namespace may use this route. // +kubebuilder:validation:Enum=All;FromList;SameNamespace // +kubebuilder:default=SameNamespace Allow GatewayAllowType `json:"allow,omitempty"` // GatewayRefs must be specified when Allow is set to "FromList". In that // case, only Gateways referenced in this list will be allowed to use this // route. This field is ignored for other values of "Allow". // +optional GatewayRefs []GatewayReference `json:"gatewayRefs,omitempty"` }
RouteGateways defines which Gateways will be able to use a route. If this field results in preventing the selection of a Route by a Gateway, an "Admitted" condition with a status of false must be set for the Gateway on that Route.
func (*RouteGateways) DeepCopy ¶
func (in *RouteGateways) DeepCopy() *RouteGateways
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteGateways.
func (*RouteGateways) DeepCopyInto ¶
func (in *RouteGateways) DeepCopyInto(out *RouteGateways)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type RouteNamespaces ¶
type RouteNamespaces struct { // From indicates where Routes will be selected for this Gateway. Possible // values are: // * All: Routes in all namespaces may be used by this Gateway. // * Selector: Routes in namespaces selected by the selector may be used by // this Gateway. // * Same: Only Routes in the same namespace may be used by this Gateway. // // Support: Core From RouteSelectType `json:"from,omitempty"` // Selector must be specified when From is set to "Selector". In that case, // only Routes in Namespaces matching this Selector will be selected by this // Gateway. This field is ignored for other values of "From". // // Support: Core // // +optional Selector metav1.LabelSelector `json:"selector,omitempty"` }
RouteNamespaces indicate which namespaces Routes should be selected from.
func (*RouteNamespaces) DeepCopy ¶
func (in *RouteNamespaces) DeepCopy() *RouteNamespaces
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteNamespaces.
func (*RouteNamespaces) DeepCopyInto ¶
func (in *RouteNamespaces) DeepCopyInto(out *RouteNamespaces)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type RouteSelectType ¶
type RouteSelectType string
RouteSelectType specifies where Routes should be selected by a Gateway. +kubebuilder:validation:Enum=All;Selector;Same +kubebuilder:default=Same
const ( // RouteSelectAll indicates that Routes in all namespaces may be used by // this Gateway. RouteSelectAll RouteSelectType = "All" // RouteSelectSelector indicates that only Routes in namespaces selected by // the selector may be used by this Gateway. RouteSelectSelector RouteSelectType = "Selector" // RouteSelectSame indicates that Only Routes in the same namespace may be // used by this Gateway. RouteSelectSame RouteSelectType = "Same" )
type RouteStatus ¶
type RouteStatus struct { // Gateways is a list of the Gateways that are associated with the // route, and the status of the route with respect to each of these // Gateways. When a Gateway selects this route, the controller that // manages the Gateway should add an entry to this list when the // controller first sees the route and should update the entry as // appropriate when the route is modified. // // A maximum of 100 Gateways will be represented in this list. If this list // is full, there may be additional Gateways using this Route that are not // included in the list. // // +kubebuilder:validation:MaxItems=100 Gateways []RouteGatewayStatus `json:"gateways"` }
RouteStatus defines the observed state that is required across all route types.
func (*RouteStatus) DeepCopy ¶
func (in *RouteStatus) DeepCopy() *RouteStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteStatus.
func (*RouteStatus) DeepCopyInto ¶
func (in *RouteStatus) DeepCopyInto(out *RouteStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type RouteTLSConfig ¶
type RouteTLSConfig struct { // CertificateRef refers to a Kubernetes object that // contains a TLS certificate and private key. // This certificate MUST be used for TLS handshakes for the domain // this RouteTLSConfig is associated with. // If an entry in this list omits or specifies the empty // string for both the group and kind, the resource defaults to "secrets". // An implementation may support other resources (for example, resource // "mycertificates" in group "networking.acme.io"). // Support: Core (Kubernetes Secrets) // Support: Implementation-specific (Other resource types) // // +required CertificateRef LocalObjectReference `json:"certificateRef"` }
RouteTLSConfig describes a TLS configuration defined at the Route level.
func (*RouteTLSConfig) DeepCopy ¶
func (in *RouteTLSConfig) DeepCopy() *RouteTLSConfig
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RouteTLSConfig.
func (*RouteTLSConfig) DeepCopyInto ¶
func (in *RouteTLSConfig) DeepCopyInto(out *RouteTLSConfig)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TCPRoute ¶
type TCPRoute struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` Spec TCPRouteSpec `json:"spec,omitempty"` Status TCPRouteStatus `json:"status,omitempty"` }
TCPRoute is the Schema for the TCPRoute resource.
func (*TCPRoute) DeepCopy ¶
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPRoute.
func (*TCPRoute) DeepCopyInto ¶
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*TCPRoute) DeepCopyObject ¶
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type TCPRouteList ¶
type TCPRouteList struct { metav1.TypeMeta `json:",inline"` metav1.ListMeta `json:"metadata,omitempty"` Items []TCPRoute `json:"items"` }
TCPRouteList contains a list of TCPRoute
func (*TCPRouteList) DeepCopy ¶
func (in *TCPRouteList) DeepCopy() *TCPRouteList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPRouteList.
func (*TCPRouteList) DeepCopyInto ¶
func (in *TCPRouteList) DeepCopyInto(out *TCPRouteList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*TCPRouteList) DeepCopyObject ¶
func (in *TCPRouteList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type TCPRouteMatch ¶
type TCPRouteMatch struct { // ExtensionRef is an optional, implementation-specific extension to the // "match" behavior. For example, resource "mytcproutematcher" in group // "networking.acme.io". If the referent cannot be found, the rule is not // included in the route. The controller should raise the "ResolvedRefs" // condition on the Gateway with the "DegradedRoutes" reason. The gateway // status for this route should be updated with a condition that describes // the error more specifically. // // Support: custom // // +optional ExtensionRef *LocalObjectReference `json:"extensionRef,omitempty"` }
TCPRouteMatch defines the predicate used to match connections to a given action.
func (*TCPRouteMatch) DeepCopy ¶
func (in *TCPRouteMatch) DeepCopy() *TCPRouteMatch
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPRouteMatch.
func (*TCPRouteMatch) DeepCopyInto ¶
func (in *TCPRouteMatch) DeepCopyInto(out *TCPRouteMatch)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TCPRouteRule ¶
type TCPRouteRule struct { // Matches define conditions used for matching the rule against // incoming TCP connections. Each match is independent, i.e. this // rule will be matched if **any** one of the matches is satisfied. // If unspecified, all requests from the associated gateway TCP // listener will match. // // +optional // +kubebuilder:validation:MaxItems=8 Matches []TCPRouteMatch `json:"matches,omitempty"` // ForwardTo defines the backend(s) where matching requests should // be sent. // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=4 ForwardTo []RouteForwardTo `json:"forwardTo"` }
TCPRouteRule is the configuration for a given rule.
func (*TCPRouteRule) DeepCopy ¶
func (in *TCPRouteRule) DeepCopy() *TCPRouteRule
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPRouteRule.
func (*TCPRouteRule) DeepCopyInto ¶
func (in *TCPRouteRule) DeepCopyInto(out *TCPRouteRule)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TCPRouteSpec ¶
type TCPRouteSpec struct { // Rules are a list of TCP matchers and actions. // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=16 Rules []TCPRouteRule `json:"rules"` // Gateways defines which Gateways can use this Route. // // +kubebuilder:default={allow: "SameNamespace"} Gateways RouteGateways `json:"gateways,omitempty"` }
TCPRouteSpec defines the desired state of TCPRoute
func (*TCPRouteSpec) DeepCopy ¶
func (in *TCPRouteSpec) DeepCopy() *TCPRouteSpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPRouteSpec.
func (*TCPRouteSpec) DeepCopyInto ¶
func (in *TCPRouteSpec) DeepCopyInto(out *TCPRouteSpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TCPRouteStatus ¶
type TCPRouteStatus struct {
RouteStatus `json:",inline"`
}
TCPRouteStatus defines the observed state of TCPRoute
func (*TCPRouteStatus) DeepCopy ¶
func (in *TCPRouteStatus) DeepCopy() *TCPRouteStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TCPRouteStatus.
func (*TCPRouteStatus) DeepCopyInto ¶
func (in *TCPRouteStatus) DeepCopyInto(out *TCPRouteStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TLSModeType ¶
type TLSModeType string
TLSModeType type defines behavior of gateway with TLS protocol. +kubebuilder:validation:Enum=Terminate;Passthrough +kubebuilder:default=Terminate
const ( // TLSModeTerminate represents the Terminate mode. // In this mode, TLS session between the downstream client // and the Gateway is terminated at the Gateway. TLSModeTerminate TLSModeType = "Terminate" // TLSModePassthrough represents the Passthrough mode. // In this mode, the TLS session NOT terminated by the Gateway. This // implies that the Gateway can't decipher the TLS stream except for // the ClientHello message of the TLS protocol. TLSModePassthrough TLSModeType = "Passthrough" )
type TLSOverridePolicy ¶
type TLSOverridePolicy struct { // Certificate dictates if TLS certificates can be configured // via Routes. If set to 'Allow', a TLS certificate for a hostname // defined in a Route takes precedence over the certificate defined in // Gateway. // // Support: Core // // +kubebuilder:default=Deny Certificate TLSRouteOverrideType `json:"certificate"` }
TLSOverridePolicy defines a schema for overriding TLS settings at the Route level.
func (*TLSOverridePolicy) DeepCopy ¶
func (in *TLSOverridePolicy) DeepCopy() *TLSOverridePolicy
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSOverridePolicy.
func (*TLSOverridePolicy) DeepCopyInto ¶
func (in *TLSOverridePolicy) DeepCopyInto(out *TLSOverridePolicy)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TLSRoute ¶
type TLSRoute struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` Spec TLSRouteSpec `json:"spec,omitempty"` Status TLSRouteStatus `json:"status,omitempty"` }
TLSRoute is the Schema for the TLSRoute resource. TLSRoute is similar to TCPRoute but can be configured to match against TLS-specific metadata. This allows more flexibility in matching streams for a given TLS listener.
If you need to forward traffic to a single target for a TLS listener, you could chose to use a TCPRoute with a TLS listener.
func (*TLSRoute) DeepCopy ¶
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSRoute.
func (*TLSRoute) DeepCopyInto ¶
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*TLSRoute) DeepCopyObject ¶
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type TLSRouteList ¶
type TLSRouteList struct { metav1.TypeMeta `json:",inline"` metav1.ListMeta `json:"metadata,omitempty"` Items []TLSRoute `json:"items"` }
TLSRouteList contains a list of TLSRoute
func (*TLSRouteList) DeepCopy ¶
func (in *TLSRouteList) DeepCopy() *TLSRouteList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSRouteList.
func (*TLSRouteList) DeepCopyInto ¶
func (in *TLSRouteList) DeepCopyInto(out *TLSRouteList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*TLSRouteList) DeepCopyObject ¶
func (in *TLSRouteList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type TLSRouteMatch ¶
type TLSRouteMatch struct { // SNIs defines a set of SNI names that should match against the // SNI attribute of TLS ClientHello message in TLS handshake. // // SNI 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"). // The wildcard character '*' must appear by itself as the first DNS label // and matches only a single label. You cannot have a wildcard label by // itself (e.g. Host == "*"). // // Requests will be matched against the Host field in the following order: // // 1. If SNI is precise, the request matches this rule if the SNI in // ClientHello is equal to one of the defined SNIs. // 2. If SNI is a wildcard, then the request matches this rule if the // SNI is to equal to the suffix (removing the first label) of the // wildcard rule. // 3. If SNIs is unspecified, all requests associated with the gateway TLS // listener will match. This can be used to define a default backend // for a TLS listener. // // Support: core // // +optional // +kubebuilder:validation:MaxItems=16 SNIs []Hostname `json:"snis,omitempty"` // ExtensionRef is an optional, implementation-specific extension to the // "match" behavior. For example, resource "mytlsroutematcher" in group // "networking.acme.io". If the referent cannot be found, the rule is not // included in the route. The controller should raise the "ResolvedRefs" // condition on the Gateway with the "DegradedRoutes" reason. The gateway // status for this route should be updated with a condition that describes // the error more specifically. // // Support: custom // // +optional ExtensionRef *LocalObjectReference `json:"extensionRef,omitempty"` }
TLSRouteMatch defines the predicate used to match connections to a given action.
func (*TLSRouteMatch) DeepCopy ¶
func (in *TLSRouteMatch) DeepCopy() *TLSRouteMatch
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSRouteMatch.
func (*TLSRouteMatch) DeepCopyInto ¶
func (in *TLSRouteMatch) DeepCopyInto(out *TLSRouteMatch)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TLSRouteOverrideType ¶
type TLSRouteOverrideType string
TLSRouteOverrideType type defines the level of allowance for Routes to override a specific TLS setting. +kubebuilder:validation:Enum=Allow;Deny +kubebuilder:default=Deny
const ( // TLSROuteOVerrideAllow allows the parameter to be configured from all routes. TLSROuteOVerrideAllow TLSRouteOverrideType = "Allow" // TLSRouteOverrideDeny prohibits the parameter to be configured from any route. TLSRouteOverrideDeny TLSRouteOverrideType = "Deny" )
type TLSRouteRule ¶
type TLSRouteRule struct { // Matches define conditions used for matching the rule against an // incoming TLS handshake. Each match is independent, i.e. this // rule will be matched if **any** one of the matches is satisfied. // If unspecified, all requests from the associated gateway TLS // listener will match. // // +optional // +kubebuilder:validation:MaxItems=8 Matches []TLSRouteMatch `json:"matches,omitempty"` // ForwardTo defines the backend(s) where matching requests should be // sent. // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=4 ForwardTo []RouteForwardTo `json:"forwardTo"` }
TLSRouteRule is the configuration for a given rule.
func (*TLSRouteRule) DeepCopy ¶
func (in *TLSRouteRule) DeepCopy() *TLSRouteRule
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSRouteRule.
func (*TLSRouteRule) DeepCopyInto ¶
func (in *TLSRouteRule) DeepCopyInto(out *TLSRouteRule)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TLSRouteSpec ¶
type TLSRouteSpec struct { // Rules are a list of TLS matchers and actions. // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=16 Rules []TLSRouteRule `json:"rules"` // Gateways defines which Gateways can use this Route. // +kubebuilder:default={allow: "SameNamespace"} Gateways RouteGateways `json:"gateways,omitempty"` }
TLSRouteSpec defines the desired state of TLSRoute
func (*TLSRouteSpec) DeepCopy ¶
func (in *TLSRouteSpec) DeepCopy() *TLSRouteSpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSRouteSpec.
func (*TLSRouteSpec) DeepCopyInto ¶
func (in *TLSRouteSpec) DeepCopyInto(out *TLSRouteSpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type TLSRouteStatus ¶
type TLSRouteStatus struct {
RouteStatus `json:",inline"`
}
TLSRouteStatus defines the observed state of TLSRoute
func (*TLSRouteStatus) DeepCopy ¶
func (in *TLSRouteStatus) DeepCopy() *TLSRouteStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSRouteStatus.
func (*TLSRouteStatus) DeepCopyInto ¶
func (in *TLSRouteStatus) DeepCopyInto(out *TLSRouteStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type UDPRoute ¶
type UDPRoute struct { metav1.TypeMeta `json:",inline"` metav1.ObjectMeta `json:"metadata,omitempty"` Spec UDPRouteSpec `json:"spec,omitempty"` Status UDPRouteStatus `json:"status,omitempty"` }
UDPRoute is the Schema for the UDPRoute resource.
func (*UDPRoute) DeepCopy ¶
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UDPRoute.
func (*UDPRoute) DeepCopyInto ¶
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*UDPRoute) DeepCopyObject ¶
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type UDPRouteList ¶
type UDPRouteList struct { metav1.TypeMeta `json:",inline"` metav1.ListMeta `json:"metadata,omitempty"` Items []UDPRoute `json:"items"` }
UDPRouteList contains a list of UDPRoute
func (*UDPRouteList) DeepCopy ¶
func (in *UDPRouteList) DeepCopy() *UDPRouteList
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UDPRouteList.
func (*UDPRouteList) DeepCopyInto ¶
func (in *UDPRouteList) DeepCopyInto(out *UDPRouteList)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (*UDPRouteList) DeepCopyObject ¶
func (in *UDPRouteList) DeepCopyObject() runtime.Object
DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
type UDPRouteMatch ¶
type UDPRouteMatch struct { // ExtensionRef is an optional, implementation-specific extension to the // "match" behavior. For example, resource "myudproutematcher" in group // "networking.acme.io". If the referent cannot be found, the rule is not // included in the route. The controller should raise the "ResolvedRefs" // condition on the Gateway with the "DegradedRoutes" reason. The gateway // status for this route should be updated with a condition that describes // the error more specifically. // // Support: custom // // +optional ExtensionRef *LocalObjectReference `json:"extensionRef,omitempty"` }
UDPRouteMatch defines the predicate used to match packets to a given action.
func (*UDPRouteMatch) DeepCopy ¶
func (in *UDPRouteMatch) DeepCopy() *UDPRouteMatch
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UDPRouteMatch.
func (*UDPRouteMatch) DeepCopyInto ¶
func (in *UDPRouteMatch) DeepCopyInto(out *UDPRouteMatch)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type UDPRouteRule ¶
type UDPRouteRule struct { // Matches define conditions used for matching the rule against // incoming UDP connections. Each match is independent, i.e. this // rule will be matched if **any** one of the matches is satisfied. // If unspecified, all requests from the associated gateway UDP // listener will match. // // +optional // +kubebuilder:validation:MaxItems=8 Matches []UDPRouteMatch `json:"matches,omitempty"` // ForwardTo defines the backend(s) where matching requests should // be sent. // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=4 ForwardTo []RouteForwardTo `json:"forwardTo"` }
UDPRouteRule is the configuration for a given rule.
func (*UDPRouteRule) DeepCopy ¶
func (in *UDPRouteRule) DeepCopy() *UDPRouteRule
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UDPRouteRule.
func (*UDPRouteRule) DeepCopyInto ¶
func (in *UDPRouteRule) DeepCopyInto(out *UDPRouteRule)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type UDPRouteSpec ¶
type UDPRouteSpec struct { // Rules are a list of UDP matchers and actions. // // +kubebuilder:validation:MinItems=1 // +kubebuilder:validation:MaxItems=16 Rules []UDPRouteRule `json:"rules"` // Gateways defines which Gateways can use this Route. // +kubebuilder:default={allow: "SameNamespace"} Gateways RouteGateways `json:"gateways,omitempty"` }
UDPRouteSpec defines the desired state of UDPRoute.
func (*UDPRouteSpec) DeepCopy ¶
func (in *UDPRouteSpec) DeepCopy() *UDPRouteSpec
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UDPRouteSpec.
func (*UDPRouteSpec) DeepCopyInto ¶
func (in *UDPRouteSpec) DeepCopyInto(out *UDPRouteSpec)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
type UDPRouteStatus ¶
type UDPRouteStatus struct {
RouteStatus `json:",inline"`
}
UDPRouteStatus defines the observed state of UDPRoute.
func (*UDPRouteStatus) DeepCopy ¶
func (in *UDPRouteStatus) DeepCopy() *UDPRouteStatus
DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UDPRouteStatus.
func (*UDPRouteStatus) DeepCopyInto ¶
func (in *UDPRouteStatus) DeepCopyInto(out *UDPRouteStatus)
DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.