Documentation

Index

Constants

View Source
const (
	// IngressClassParametersReferenceScopeNamespace indicates that the
	// referenced Parameters resource is namespace-scoped.
	IngressClassParametersReferenceScopeNamespace = "Namespace"
	// IngressClassParametersReferenceScopeNamespace indicates that the
	// referenced Parameters resource is cluster-scoped.
	IngressClassParametersReferenceScopeCluster = "Cluster"
)
View Source
const (
	// PathTypeExact matches the URL path exactly and with case sensitivity.
	PathTypeExact = PathType("Exact")

	// PathTypePrefix matches based on a URL path prefix split by '/'. Matching
	// is case sensitive and done on a path element by element basis. A path
	// element refers to the list of labels in the path split by the '/'
	// separator. A request is a match for path p if every p is an element-wise
	// prefix of p of the request path. Note that if the last element of the
	// path is a substring of the last element in request path, it is not a
	// match (e.g. /foo/bar matches /foo/bar/baz, but does not match
	// /foo/barbaz). If multiple matching paths exist in an Ingress spec, the
	// longest matching path is given priority.
	// Examples:
	// - /foo/bar does not match requests to /foo/barbaz
	// - /foo/bar matches request to /foo/bar and /foo/bar/baz
	// - /foo and /foo/ both match requests to /foo and /foo/. If both paths are
	//   present in an Ingress spec, the longest matching path (/foo/) is given
	//   priority.
	PathTypePrefix = PathType("Prefix")

	// PathTypeImplementationSpecific matching is up to the IngressClass.
	// Implementations can treat this as a separate PathType or treat it
	// identically to Prefix or Exact path types.
	PathTypeImplementationSpecific = PathType("ImplementationSpecific")
)
View Source
const GroupName = "networking.k8s.io"

    GroupName is the group name use in this package

    Variables

    View Source
    var (
    	// SchemeBuilder points to a list of functions added to Scheme.
    	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
    	// AddToScheme applies all the stored functions to the scheme.
    	AddToScheme = SchemeBuilder.AddToScheme
    )
    View Source
    var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal}

      SchemeGroupVersion is group version used to register these objects

      Functions

      func Kind

      func Kind(kind string) schema.GroupKind

        Kind takes an unqualified kind and returns a Group qualified GroupKind

        func Resource

        func Resource(resource string) schema.GroupResource

          Resource takes an unqualified resource and returns a Group qualified GroupResource

          Types

          type HTTPIngressPath

          type HTTPIngressPath struct {
          	// Path is matched against the path of an incoming request. Currently it can
          	// contain characters disallowed from the conventional "path" part of a URL
          	// as defined by RFC 3986. Paths must begin with a '/'. When unspecified,
          	// all paths from incoming requests are matched.
          	// +optional
          	Path string
          
          	// PathType determines the interpretation of the Path matching. PathType can
          	// be one of Exact, Prefix, or ImplementationSpecific. Implementations are
          	// required to support all path types.
          	// +optional
          	PathType *PathType
          
          	// Backend defines the referenced service endpoint to which the traffic
          	// will be forwarded to.
          	Backend IngressBackend
          }

            HTTPIngressPath associates a path with a backend. Incoming urls matching the path are forwarded to the backend.

            func (*HTTPIngressPath) DeepCopy

            func (in *HTTPIngressPath) DeepCopy() *HTTPIngressPath

              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPIngressPath.

              func (*HTTPIngressPath) DeepCopyInto

              func (in *HTTPIngressPath) DeepCopyInto(out *HTTPIngressPath)

                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                type HTTPIngressRuleValue

                type HTTPIngressRuleValue struct {
                	// A collection of paths that map requests to backends.
                	// +listType=atomic
                	Paths []HTTPIngressPath
                }

                  HTTPIngressRuleValue is a list of http selectors pointing to backends. In the example: http://<host>/<path>?<searchpart> -> backend where where parts of the url correspond to RFC 3986, this resource will be used to match against everything after the last '/' and before the first '?' or '#'.

                  func (*HTTPIngressRuleValue) DeepCopy

                    DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HTTPIngressRuleValue.

                    func (*HTTPIngressRuleValue) DeepCopyInto

                    func (in *HTTPIngressRuleValue) DeepCopyInto(out *HTTPIngressRuleValue)

                      DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                      type IPBlock

                      type IPBlock struct {
                      	// CIDR is a string representing the IP Block
                      	// Valid examples are "192.168.1.1/24" or "2001:db9::/64"
                      	CIDR string
                      	// Except is a slice of CIDRs that should not be included within an IP Block
                      	// Valid examples are "192.168.1.1/24" or "2001:db9::/64"
                      	// Except values will be rejected if they are outside the CIDR range
                      	// +optional
                      	Except []string
                      }

                        IPBlock describes a particular CIDR (Ex. "192.168.1.1/24","2001:db9::/64") that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The except entry describes CIDRs that should not be included within this rule.

                        func (*IPBlock) DeepCopy

                        func (in *IPBlock) DeepCopy() *IPBlock

                          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IPBlock.

                          func (*IPBlock) DeepCopyInto

                          func (in *IPBlock) DeepCopyInto(out *IPBlock)

                            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                            type Ingress

                            type Ingress struct {
                            	metav1.TypeMeta
                            	// Standard object's metadata.
                            	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
                            	// +optional
                            	metav1.ObjectMeta
                            
                            	// Spec is the desired state of the Ingress.
                            	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
                            	// +optional
                            	Spec IngressSpec
                            
                            	// Status is the current state of the Ingress.
                            	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
                            	// +optional
                            	Status IngressStatus
                            }

                              Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc.

                              func (*Ingress) DeepCopy

                              func (in *Ingress) DeepCopy() *Ingress

                                DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Ingress.

                                func (*Ingress) DeepCopyInto

                                func (in *Ingress) DeepCopyInto(out *Ingress)

                                  DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                  func (*Ingress) DeepCopyObject

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

                                    DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                    type IngressBackend

                                    type IngressBackend struct {
                                    	// Service references a Service as a Backend.
                                    	// This is a mutually exclusive setting with "Resource".
                                    	// +optional
                                    	Service *IngressServiceBackend
                                    
                                    	// Resource is an ObjectRef to another Kubernetes resource in the namespace
                                    	// of the Ingress object. If resource is specified, a service.Name and
                                    	// service.Port must not be specified.
                                    	// This is a mutually exclusive setting with "Service".
                                    	// +optional
                                    	Resource *api.TypedLocalObjectReference
                                    }

                                      IngressBackend describes all endpoints for a given service and port.

                                      func (*IngressBackend) DeepCopy

                                      func (in *IngressBackend) DeepCopy() *IngressBackend

                                        DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressBackend.

                                        func (*IngressBackend) DeepCopyInto

                                        func (in *IngressBackend) DeepCopyInto(out *IngressBackend)

                                          DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                          type IngressClass

                                          type IngressClass struct {
                                          	metav1.TypeMeta
                                          	metav1.ObjectMeta
                                          
                                          	// Spec is the desired state of the IngressClass.
                                          	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
                                          	// +optional
                                          	Spec IngressClassSpec
                                          }

                                            IngressClass represents the class of the Ingress, referenced by the Ingress Spec. The `ingressclass.kubernetes.io/is-default-class` annotation can be used to indicate that an IngressClass should be considered default. When a single IngressClass resource has this annotation set to true, new Ingress resources without a class specified will be assigned this default class.

                                            func (*IngressClass) DeepCopy

                                            func (in *IngressClass) DeepCopy() *IngressClass

                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressClass.

                                              func (*IngressClass) DeepCopyInto

                                              func (in *IngressClass) DeepCopyInto(out *IngressClass)

                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                func (*IngressClass) DeepCopyObject

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

                                                  DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                                  type IngressClassList

                                                  type IngressClassList struct {
                                                  	metav1.TypeMeta
                                                  	// Standard object's metadata.
                                                  	// +optional
                                                  	metav1.ListMeta
                                                  
                                                  	// Items is the list of IngressClasses.
                                                  	Items []IngressClass
                                                  }

                                                    IngressClassList is a collection of IngressClasses.

                                                    func (*IngressClassList) DeepCopy

                                                    func (in *IngressClassList) DeepCopy() *IngressClassList

                                                      DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressClassList.

                                                      func (*IngressClassList) DeepCopyInto

                                                      func (in *IngressClassList) DeepCopyInto(out *IngressClassList)

                                                        DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                        func (*IngressClassList) DeepCopyObject

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

                                                          DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                                          type IngressClassParametersReference

                                                          type IngressClassParametersReference struct {
                                                          	// APIGroup is the group for the resource being referenced. If APIGroup is
                                                          	// not specified, the specified Kind must be in the core API group. For any
                                                          	// other third-party types, APIGroup is required.
                                                          	// +optional
                                                          	APIGroup *string
                                                          	// Kind is the type of resource being referenced.
                                                          	Kind string
                                                          	// Name is the name of resource being referenced.
                                                          	Name string
                                                          	// Scope represents if this refers to a cluster or namespace scoped resource.
                                                          	// This may be set to "Cluster" (default) or "Namespace".
                                                          	// Field can be enabled with IngressClassNamespacedParams feature gate.
                                                          	// +optional
                                                          	// +featureGate=IngressClassNamespacedParams
                                                          	Scope *string
                                                          	// Namespace is the namespace of the resource being referenced. This field is
                                                          	// required when scope is set to "Namespace" and must be unset when scope is set to
                                                          	// "Cluster".
                                                          	// +optional
                                                          	// +featureGate=IngressClassNamespacedParams
                                                          	Namespace *string
                                                          }

                                                            IngressClassParametersReference identifies an API object. This can be used to specify a cluster or namespace-scoped resource.

                                                            func (*IngressClassParametersReference) DeepCopy

                                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressClassParametersReference.

                                                              func (*IngressClassParametersReference) DeepCopyInto

                                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                type IngressClassSpec

                                                                type IngressClassSpec struct {
                                                                	// Controller refers to the name of the controller that should handle this
                                                                	// class. This allows for different "flavors" that are controlled by the
                                                                	// same controller. For example, you may have different Parameters for the
                                                                	// same implementing controller. This should be specified as a
                                                                	// domain-prefixed path no more than 250 characters in length, e.g.
                                                                	// "acme.io/ingress-controller". This field is immutable.
                                                                	Controller string
                                                                
                                                                	// Parameters is a link to a custom resource containing additional
                                                                	// configuration for the controller. This is optional if the controller does
                                                                	// not require extra parameters.
                                                                	// +optional
                                                                	Parameters *IngressClassParametersReference
                                                                }

                                                                  IngressClassSpec provides information about the class of an Ingress.

                                                                  func (*IngressClassSpec) DeepCopy

                                                                  func (in *IngressClassSpec) DeepCopy() *IngressClassSpec

                                                                    DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressClassSpec.

                                                                    func (*IngressClassSpec) DeepCopyInto

                                                                    func (in *IngressClassSpec) DeepCopyInto(out *IngressClassSpec)

                                                                      DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                      type IngressList

                                                                      type IngressList struct {
                                                                      	metav1.TypeMeta
                                                                      	// Standard object's metadata.
                                                                      	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
                                                                      	// +optional
                                                                      	metav1.ListMeta
                                                                      
                                                                      	// Items is the list of Ingress.
                                                                      	Items []Ingress
                                                                      }

                                                                        IngressList is a collection of Ingress.

                                                                        func (*IngressList) DeepCopy

                                                                        func (in *IngressList) DeepCopy() *IngressList

                                                                          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressList.

                                                                          func (*IngressList) DeepCopyInto

                                                                          func (in *IngressList) DeepCopyInto(out *IngressList)

                                                                            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                            func (*IngressList) DeepCopyObject

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

                                                                              DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                                                              type IngressRule

                                                                              type IngressRule struct {
                                                                              	// Host 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 RFC 3986:
                                                                              	// 1. IPs are not allowed. Currently an IngressRuleValue can only apply to
                                                                              	//    the IP in the Spec of the parent Ingress.
                                                                              	// 2. The `:` delimiter is not respected because ports are not allowed.
                                                                              	//	  Currently the port of an Ingress is implicitly :80 for http and
                                                                              	//	  :443 for https.
                                                                              	// Both these may change in the future.
                                                                              	// Incoming requests are matched against the host before the
                                                                              	// IngressRuleValue. If the host is unspecified, the Ingress routes all
                                                                              	// traffic based on the specified IngressRuleValue.
                                                                              	//
                                                                              	// Host can be "precise" which is a domain name without the terminating dot of
                                                                              	// a network host (e.g. "foo.bar.com") or "wildcard", which is a domain name
                                                                              	// prefixed with a single wildcard label (e.g. "*.foo.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 way:
                                                                              	// 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.
                                                                              	// +optional
                                                                              	Host string
                                                                              	// IngressRuleValue represents a rule to route requests for this
                                                                              	// IngressRule. If unspecified, the rule defaults to a http catch-all.
                                                                              	// Whether that sends just traffic matching the host to the default backend
                                                                              	// or all traffic to the default backend, is left to the controller
                                                                              	// fulfilling the Ingress. Http is currently the only supported
                                                                              	// IngressRuleValue.
                                                                              	// +optional
                                                                              	IngressRuleValue
                                                                              }

                                                                                IngressRule represents the rules mapping the paths under a specified host to the related backend services. Incoming requests are first evaluated for a host match, then routed to the backend associated with the matching IngressRuleValue.

                                                                                func (*IngressRule) DeepCopy

                                                                                func (in *IngressRule) DeepCopy() *IngressRule

                                                                                  DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressRule.

                                                                                  func (*IngressRule) DeepCopyInto

                                                                                  func (in *IngressRule) DeepCopyInto(out *IngressRule)

                                                                                    DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                    type IngressRuleValue

                                                                                    type IngressRuleValue struct {
                                                                                    
                                                                                    	// +optional
                                                                                    	HTTP *HTTPIngressRuleValue
                                                                                    }

                                                                                      IngressRuleValue represents a rule to apply against incoming requests. If the rule is satisfied, the request is routed to the specified backend. Currently mixing different types of rules in a single Ingress is disallowed, so exactly one of the following must be set.

                                                                                      func (*IngressRuleValue) DeepCopy

                                                                                      func (in *IngressRuleValue) DeepCopy() *IngressRuleValue

                                                                                        DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressRuleValue.

                                                                                        func (*IngressRuleValue) DeepCopyInto

                                                                                        func (in *IngressRuleValue) DeepCopyInto(out *IngressRuleValue)

                                                                                          DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                          type IngressServiceBackend

                                                                                          type IngressServiceBackend struct {
                                                                                          	// Name is the referenced service. The service must exist in
                                                                                          	// the same namespace as the Ingress object.
                                                                                          	Name string
                                                                                          
                                                                                          	// Port of the referenced service. A port name or port number
                                                                                          	// is required for a IngressServiceBackend.
                                                                                          	Port ServiceBackendPort
                                                                                          }

                                                                                            IngressServiceBackend references a Kubernetes Service as a Backend.

                                                                                            func (*IngressServiceBackend) DeepCopy

                                                                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressServiceBackend.

                                                                                              func (*IngressServiceBackend) DeepCopyInto

                                                                                              func (in *IngressServiceBackend) DeepCopyInto(out *IngressServiceBackend)

                                                                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                type IngressSpec

                                                                                                type IngressSpec struct {
                                                                                                	// IngressClassName is the name of the IngressClass cluster resource. The
                                                                                                	// associated IngressClass defines which controller will implement the
                                                                                                	// resource. This replaces the deprecated `kubernetes.io/ingress.class`
                                                                                                	// annotation. For backwards compatibility, when that annotation is set, it
                                                                                                	// must be given precedence over this field. The controller may emit a
                                                                                                	// warning if the field and annotation have different values.
                                                                                                	// Implementations of this API should ignore Ingresses without a class
                                                                                                	// specified. An IngressClass resource may be marked as default, which can
                                                                                                	// be used to set a default value for this field. For more information,
                                                                                                	// refer to the IngressClass documentation.
                                                                                                	// +optional
                                                                                                	IngressClassName *string
                                                                                                
                                                                                                	// DefaultBackend is the backend that should handle requests that don't
                                                                                                	// match any rule. If Rules are not specified, DefaultBackend must be specified.
                                                                                                	// If DefaultBackend is not set, the handling of requests that do not match any
                                                                                                	// of the rules will be up to the Ingress controller.
                                                                                                	// +optional
                                                                                                	DefaultBackend *IngressBackend
                                                                                                
                                                                                                	// TLS configuration. Currently the Ingress only supports a single TLS
                                                                                                	// port, 443. If multiple members of this list specify different hosts, they
                                                                                                	// will be multiplexed on the same port according to the hostname specified
                                                                                                	// through the SNI TLS extension, if the ingress controller fulfilling the
                                                                                                	// ingress supports SNI.
                                                                                                	// +listType=atomic
                                                                                                	// +optional
                                                                                                	TLS []IngressTLS
                                                                                                
                                                                                                	// A list of host rules used to configure the Ingress. If unspecified, or
                                                                                                	// no rule matches, all traffic is sent to the default backend.
                                                                                                	// +listType=atomic
                                                                                                	// +optional
                                                                                                	Rules []IngressRule
                                                                                                }

                                                                                                  IngressSpec describes the Ingress the user wishes to exist.

                                                                                                  func (*IngressSpec) DeepCopy

                                                                                                  func (in *IngressSpec) DeepCopy() *IngressSpec

                                                                                                    DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressSpec.

                                                                                                    func (*IngressSpec) DeepCopyInto

                                                                                                    func (in *IngressSpec) DeepCopyInto(out *IngressSpec)

                                                                                                      DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                      type IngressStatus

                                                                                                      type IngressStatus struct {
                                                                                                      	// LoadBalancer contains the current status of the load-balancer.
                                                                                                      	// +optional
                                                                                                      	LoadBalancer api.LoadBalancerStatus
                                                                                                      }

                                                                                                        IngressStatus describe the current state of the Ingress.

                                                                                                        func (*IngressStatus) DeepCopy

                                                                                                        func (in *IngressStatus) DeepCopy() *IngressStatus

                                                                                                          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressStatus.

                                                                                                          func (*IngressStatus) DeepCopyInto

                                                                                                          func (in *IngressStatus) DeepCopyInto(out *IngressStatus)

                                                                                                            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                            type IngressTLS

                                                                                                            type IngressTLS struct {
                                                                                                            	// Hosts are a list of hosts included in the TLS certificate. The values in
                                                                                                            	// this list must match the name/s used in the tlsSecret. Defaults to the
                                                                                                            	// wildcard host setting for the loadbalancer controller fulfilling this
                                                                                                            	// Ingress, if left unspecified.
                                                                                                            	// +listType=atomic
                                                                                                            	// +optional
                                                                                                            	Hosts []string
                                                                                                            	// SecretName is the name of the secret used to terminate TLS traffic on
                                                                                                            	// port 443. Field is left optional to allow TLS routing based on SNI
                                                                                                            	// hostname alone. If the SNI host in a listener conflicts with the "Host"
                                                                                                            	// header field used by an IngressRule, the SNI host is used for termination
                                                                                                            	// and value of the Host header is used for routing.
                                                                                                            	// +optional
                                                                                                            	SecretName string
                                                                                                            }

                                                                                                              IngressTLS describes the transport layer security associated with an Ingress.

                                                                                                              func (*IngressTLS) DeepCopy

                                                                                                              func (in *IngressTLS) DeepCopy() *IngressTLS

                                                                                                                DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngressTLS.

                                                                                                                func (*IngressTLS) DeepCopyInto

                                                                                                                func (in *IngressTLS) DeepCopyInto(out *IngressTLS)

                                                                                                                  DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                  type NetworkPolicy

                                                                                                                  type NetworkPolicy struct {
                                                                                                                  	metav1.TypeMeta
                                                                                                                  	// +optional
                                                                                                                  	metav1.ObjectMeta
                                                                                                                  
                                                                                                                  	// Specification of the desired behavior for this NetworkPolicy.
                                                                                                                  	// +optional
                                                                                                                  	Spec NetworkPolicySpec
                                                                                                                  }

                                                                                                                    NetworkPolicy describes what network traffic is allowed for a set of Pods

                                                                                                                    func (*NetworkPolicy) DeepCopy

                                                                                                                    func (in *NetworkPolicy) DeepCopy() *NetworkPolicy

                                                                                                                      DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicy.

                                                                                                                      func (*NetworkPolicy) DeepCopyInto

                                                                                                                      func (in *NetworkPolicy) DeepCopyInto(out *NetworkPolicy)

                                                                                                                        DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                        func (*NetworkPolicy) DeepCopyObject

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

                                                                                                                          DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                                                                                                          type NetworkPolicyEgressRule

                                                                                                                          type NetworkPolicyEgressRule struct {
                                                                                                                          	// List of destination ports for outgoing traffic.
                                                                                                                          	// Each item in this list is combined using a logical OR. If this field is
                                                                                                                          	// empty or missing, this rule matches all ports (traffic not restricted by port).
                                                                                                                          	// If this field is present and contains at least one item, then this rule allows
                                                                                                                          	// traffic only if the traffic matches at least one port in the list.
                                                                                                                          	// +optional
                                                                                                                          	Ports []NetworkPolicyPort
                                                                                                                          
                                                                                                                          	// List of destinations for outgoing traffic of pods selected for this rule.
                                                                                                                          	// Items in this list are combined using a logical OR operation. If this field is
                                                                                                                          	// empty or missing, this rule matches all destinations (traffic not restricted by
                                                                                                                          	// destination). If this field is present and contains at least one item, this rule
                                                                                                                          	// allows traffic only if the traffic matches at least one item in the to list.
                                                                                                                          	// +optional
                                                                                                                          	To []NetworkPolicyPeer
                                                                                                                          }

                                                                                                                            NetworkPolicyEgressRule describes a particular set of traffic that is allowed out of pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and to. This type is beta-level in 1.8

                                                                                                                            func (*NetworkPolicyEgressRule) DeepCopy

                                                                                                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicyEgressRule.

                                                                                                                              func (*NetworkPolicyEgressRule) DeepCopyInto

                                                                                                                              func (in *NetworkPolicyEgressRule) DeepCopyInto(out *NetworkPolicyEgressRule)

                                                                                                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                type NetworkPolicyIngressRule

                                                                                                                                type NetworkPolicyIngressRule struct {
                                                                                                                                	// List of ports which should be made accessible on the pods selected for this
                                                                                                                                	// rule. Each item in this list is combined using a logical OR. If this field is
                                                                                                                                	// empty or missing, this rule matches all ports (traffic not restricted by port).
                                                                                                                                	// If this field is present and contains at least one item, then this rule allows
                                                                                                                                	// traffic only if the traffic matches at least one port in the list.
                                                                                                                                	// +optional
                                                                                                                                	Ports []NetworkPolicyPort
                                                                                                                                
                                                                                                                                	// List of sources which should be able to access the pods selected for this rule.
                                                                                                                                	// Items in this list are combined using a logical OR operation. If this field is
                                                                                                                                	// empty or missing, this rule matches all sources (traffic not restricted by
                                                                                                                                	// source). If this field is present and contains at least one item, this rule
                                                                                                                                	// allows traffic only if the traffic matches at least one item in the from list.
                                                                                                                                	// +optional
                                                                                                                                	From []NetworkPolicyPeer
                                                                                                                                }

                                                                                                                                  NetworkPolicyIngressRule describes a particular set of traffic that is allowed to the pods matched by a NetworkPolicySpec's podSelector. The traffic must match both ports and from.

                                                                                                                                  func (*NetworkPolicyIngressRule) DeepCopy

                                                                                                                                    DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicyIngressRule.

                                                                                                                                    func (*NetworkPolicyIngressRule) DeepCopyInto

                                                                                                                                    func (in *NetworkPolicyIngressRule) DeepCopyInto(out *NetworkPolicyIngressRule)

                                                                                                                                      DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                      type NetworkPolicyList

                                                                                                                                      type NetworkPolicyList struct {
                                                                                                                                      	metav1.TypeMeta
                                                                                                                                      	// +optional
                                                                                                                                      	metav1.ListMeta
                                                                                                                                      
                                                                                                                                      	Items []NetworkPolicy
                                                                                                                                      }

                                                                                                                                        NetworkPolicyList is a list of NetworkPolicy objects.

                                                                                                                                        func (*NetworkPolicyList) DeepCopy

                                                                                                                                        func (in *NetworkPolicyList) DeepCopy() *NetworkPolicyList

                                                                                                                                          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicyList.

                                                                                                                                          func (*NetworkPolicyList) DeepCopyInto

                                                                                                                                          func (in *NetworkPolicyList) DeepCopyInto(out *NetworkPolicyList)

                                                                                                                                            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                            func (*NetworkPolicyList) DeepCopyObject

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

                                                                                                                                              DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                                                                                                                              type NetworkPolicyPeer

                                                                                                                                              type NetworkPolicyPeer struct {
                                                                                                                                              	// This is a label selector which selects Pods. This field follows standard label
                                                                                                                                              	// selector semantics; if present but empty, it selects all pods.
                                                                                                                                              	//
                                                                                                                                              	// If NamespaceSelector is also set, then the NetworkPolicyPeer as a whole selects
                                                                                                                                              	// the Pods matching PodSelector in the Namespaces selected by NamespaceSelector.
                                                                                                                                              	// Otherwise it selects the Pods matching PodSelector in the policy's own Namespace.
                                                                                                                                              	// +optional
                                                                                                                                              	PodSelector *metav1.LabelSelector
                                                                                                                                              
                                                                                                                                              	// Selects Namespaces using cluster-scoped labels. This field follows standard label
                                                                                                                                              	// selector semantics; if present but empty, it selects all namespaces.
                                                                                                                                              	//
                                                                                                                                              	// If PodSelector is also set, then the NetworkPolicyPeer as a whole selects
                                                                                                                                              	// the Pods matching PodSelector in the Namespaces selected by NamespaceSelector.
                                                                                                                                              	// Otherwise it selects all Pods in the Namespaces selected by NamespaceSelector.
                                                                                                                                              	// +optional
                                                                                                                                              	NamespaceSelector *metav1.LabelSelector
                                                                                                                                              
                                                                                                                                              	// IPBlock defines policy on a particular IPBlock. If this field is set then
                                                                                                                                              	// neither of the other fields can be.
                                                                                                                                              	// +optional
                                                                                                                                              	IPBlock *IPBlock
                                                                                                                                              }

                                                                                                                                                NetworkPolicyPeer describes a peer to allow traffic to/from.

                                                                                                                                                func (*NetworkPolicyPeer) DeepCopy

                                                                                                                                                func (in *NetworkPolicyPeer) DeepCopy() *NetworkPolicyPeer

                                                                                                                                                  DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicyPeer.

                                                                                                                                                  func (*NetworkPolicyPeer) DeepCopyInto

                                                                                                                                                  func (in *NetworkPolicyPeer) DeepCopyInto(out *NetworkPolicyPeer)

                                                                                                                                                    DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                    type NetworkPolicyPort

                                                                                                                                                    type NetworkPolicyPort struct {
                                                                                                                                                    	// The protocol (TCP, UDP, or SCTP) which traffic must match. If not specified, this
                                                                                                                                                    	// field defaults to TCP.
                                                                                                                                                    	// +optional
                                                                                                                                                    	Protocol *api.Protocol
                                                                                                                                                    
                                                                                                                                                    	// The port on the given protocol. This can either be a numerical or named
                                                                                                                                                    	// port on a pod. If this field is not provided, this matches all port names and
                                                                                                                                                    	// numbers.
                                                                                                                                                    	// If present, only traffic on the specified protocol AND port will be matched.
                                                                                                                                                    	// +optional
                                                                                                                                                    	Port *intstr.IntOrString
                                                                                                                                                    
                                                                                                                                                    	// If set, indicates that the range of ports from port to endPort, inclusive,
                                                                                                                                                    	// should be allowed by the policy. This field cannot be defined if the port field
                                                                                                                                                    	// is not defined or if the port field is defined as a named (string) port.
                                                                                                                                                    	// The endPort must be equal or greater than port.
                                                                                                                                                    	// This feature is in Alpha state and should be enabled using the Feature Gate
                                                                                                                                                    	// "NetworkPolicyEndPort".
                                                                                                                                                    	// +optional
                                                                                                                                                    	EndPort *int32
                                                                                                                                                    }

                                                                                                                                                      NetworkPolicyPort describes a port to allow traffic on

                                                                                                                                                      func (*NetworkPolicyPort) DeepCopy

                                                                                                                                                      func (in *NetworkPolicyPort) DeepCopy() *NetworkPolicyPort

                                                                                                                                                        DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicyPort.

                                                                                                                                                        func (*NetworkPolicyPort) DeepCopyInto

                                                                                                                                                        func (in *NetworkPolicyPort) DeepCopyInto(out *NetworkPolicyPort)

                                                                                                                                                          DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                          type NetworkPolicySpec

                                                                                                                                                          type NetworkPolicySpec struct {
                                                                                                                                                          	// Selects the pods to which this NetworkPolicy object applies. The array of
                                                                                                                                                          	// ingress rules is applied to any pods selected by this field. Multiple network
                                                                                                                                                          	// policies can select the same set of pods. In this case, the ingress rules for
                                                                                                                                                          	// each are combined additively. This field is NOT optional and follows standard
                                                                                                                                                          	// label selector semantics. An empty podSelector matches all pods in this
                                                                                                                                                          	// namespace.
                                                                                                                                                          	PodSelector metav1.LabelSelector
                                                                                                                                                          
                                                                                                                                                          	// List of ingress rules to be applied to the selected pods. Traffic is allowed to
                                                                                                                                                          	// a pod if there are no NetworkPolicies selecting the pod
                                                                                                                                                          	// (and cluster policy otherwise allows the traffic), OR if the traffic source is
                                                                                                                                                          	// the pod's local node, OR if the traffic matches at least one ingress rule
                                                                                                                                                          	// across all of the NetworkPolicy objects whose podSelector matches the pod. If
                                                                                                                                                          	// this field is empty then this NetworkPolicy does not allow any traffic (and serves
                                                                                                                                                          	// solely to ensure that the pods it selects are isolated by default)
                                                                                                                                                          	// +optional
                                                                                                                                                          	Ingress []NetworkPolicyIngressRule
                                                                                                                                                          
                                                                                                                                                          	// List of egress rules to be applied to the selected pods. Outgoing traffic is
                                                                                                                                                          	// allowed if there are no NetworkPolicies selecting the pod (and cluster policy
                                                                                                                                                          	// otherwise allows the traffic), OR if the traffic matches at least one egress rule
                                                                                                                                                          	// across all of the NetworkPolicy objects whose podSelector matches the pod. If
                                                                                                                                                          	// this field is empty then this NetworkPolicy limits all outgoing traffic (and serves
                                                                                                                                                          	// solely to ensure that the pods it selects are isolated by default).
                                                                                                                                                          	// This field is beta-level in 1.8
                                                                                                                                                          	// +optional
                                                                                                                                                          	Egress []NetworkPolicyEgressRule
                                                                                                                                                          
                                                                                                                                                          	// List of rule types that the NetworkPolicy relates to.
                                                                                                                                                          	// Valid options are ["Ingress"], ["Egress"], or ["Ingress", "Egress"].
                                                                                                                                                          	// If this field is not specified, it will default based on the existence of Ingress or Egress rules;
                                                                                                                                                          	// policies that contain an Egress section are assumed to affect Egress, and all policies
                                                                                                                                                          	// (whether or not they contain an Ingress section) are assumed to affect Ingress.
                                                                                                                                                          	// If you want to write an egress-only policy, you must explicitly specify policyTypes [ "Egress" ].
                                                                                                                                                          	// Likewise, if you want to write a policy that specifies that no egress is allowed,
                                                                                                                                                          	// you must specify a policyTypes value that include "Egress" (since such a policy would not include
                                                                                                                                                          	// an Egress section and would otherwise default to just [ "Ingress" ]).
                                                                                                                                                          	// This field is beta-level in 1.8
                                                                                                                                                          	// +optional
                                                                                                                                                          	PolicyTypes []PolicyType
                                                                                                                                                          }

                                                                                                                                                            NetworkPolicySpec provides the specification of a NetworkPolicy

                                                                                                                                                            func (*NetworkPolicySpec) DeepCopy

                                                                                                                                                            func (in *NetworkPolicySpec) DeepCopy() *NetworkPolicySpec

                                                                                                                                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new NetworkPolicySpec.

                                                                                                                                                              func (*NetworkPolicySpec) DeepCopyInto

                                                                                                                                                              func (in *NetworkPolicySpec) DeepCopyInto(out *NetworkPolicySpec)

                                                                                                                                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                                type PathType

                                                                                                                                                                type PathType string

                                                                                                                                                                  PathType represents the type of path referred to by a HTTPIngressPath.

                                                                                                                                                                  type PolicyType

                                                                                                                                                                  type PolicyType string

                                                                                                                                                                    PolicyType describes the NetworkPolicy type This type is beta-level in 1.8

                                                                                                                                                                    const (
                                                                                                                                                                    	// PolicyTypeIngress is a NetworkPolicy that affects ingress traffic on selected pods
                                                                                                                                                                    	PolicyTypeIngress PolicyType = "Ingress"
                                                                                                                                                                    	// PolicyTypeEgress is a NetworkPolicy that affects egress traffic on selected pods
                                                                                                                                                                    	PolicyTypeEgress PolicyType = "Egress"
                                                                                                                                                                    )

                                                                                                                                                                    type ServiceBackendPort

                                                                                                                                                                    type ServiceBackendPort struct {
                                                                                                                                                                    	// Name is the name of the port on the Service.
                                                                                                                                                                    	// This must be an IANA_SVC_NAME (following RFC6335).
                                                                                                                                                                    	// This is a mutually exclusive setting with "Number".
                                                                                                                                                                    	// +optional
                                                                                                                                                                    	Name string
                                                                                                                                                                    
                                                                                                                                                                    	// Number is the numerical port number (e.g. 80) on the Service.
                                                                                                                                                                    	// This is a mutually exclusive setting with "Name".
                                                                                                                                                                    	// +optional
                                                                                                                                                                    	Number int32
                                                                                                                                                                    }

                                                                                                                                                                      ServiceBackendPort is the service port being referenced.

                                                                                                                                                                      func (*ServiceBackendPort) DeepCopy

                                                                                                                                                                      func (in *ServiceBackendPort) DeepCopy() *ServiceBackendPort

                                                                                                                                                                        DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ServiceBackendPort.

                                                                                                                                                                        func (*ServiceBackendPort) DeepCopyInto

                                                                                                                                                                        func (in *ServiceBackendPort) DeepCopyInto(out *ServiceBackendPort)

                                                                                                                                                                          DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                                          Directories

                                                                                                                                                                          Path Synopsis
                                                                                                                                                                          Package install installs the experimental API group, making it available as an option to all of the API encoding/decoding machinery.
                                                                                                                                                                          Package install installs the experimental API group, making it available as an option to all of the API encoding/decoding machinery.