networkingv1

package
v0.0.0-...-9e3994c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 10, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const GroupName = "networking.k8s.io"

Variables

View Source 
var (
	GroupVersion       = metav1.GroupVersion{Group: GroupName, Version: "v1"}
	SchemeBuilder      = runtime.NewSchemeBuilder(addKnownTypes)
	AddToScheme        = SchemeBuilder.AddToScheme
	SchemaGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}
)

Functions

This section is empty.

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 '/' and must be present
	// when using PathType with value "Exact" or "Prefix".
	Path string `json:"path,omitempty"`
	// pathType determines the interpretation of the path matching. PathType can
	// be one of the following values:
	// * Exact: Matches the URL path exactly.
	// * Prefix: Matches based on a URL path prefix split by '/'. Matching is
	// done on a path element by element basis. A path element refers is 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).
	// * ImplementationSpecific: Interpretation of the Path matching is up to
	// the IngressClass. Implementations can treat this as a separate PathType
	// or treat it identically to Prefix or Exact path types.
	// Implementations are required to support all path types.
	PathType PathType `json:"pathType,omitempty"`
	// backend defines the referenced service endpoint to which the traffic
	// will be forwarded to.
	Backend IngressBackend `json:"backend"`
}

func (*HTTPIngressPath) DeepCopy 

func (in *HTTPIngressPath) DeepCopy() *HTTPIngressPath

func (*HTTPIngressPath) DeepCopyInto 

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

type HTTPIngressRuleValue 

type HTTPIngressRuleValue struct {
	// paths is a collection of paths that map requests to backends.
	Paths []HTTPIngressPath `json:"paths"`
}

func (*HTTPIngressRuleValue) DeepCopy 

func (in *HTTPIngressRuleValue) DeepCopy() *HTTPIngressRuleValue

func (*HTTPIngressRuleValue) DeepCopyInto 

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

type IPBlock 

type IPBlock struct {
	// cidr is a string representing the IPBlock
	// Valid examples are "192.168.1.0/24" or "2001:db8::/64"
	CIDR string `json:"cidr"`
	// except is a slice of CIDRs that should not be included within an IPBlock
	// Valid examples are "192.168.1.0/24" or "2001:db8::/64"
	// Except values will be rejected if they are outside the cidr range
	Except []string `json:"except"`
}

func (*IPBlock) DeepCopy 

func (in *IPBlock) DeepCopy() *IPBlock

func (*IPBlock) DeepCopyInto 

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

type Ingress 

type Ingress struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`
	// 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
	Spec *IngressSpec `json:"spec,omitempty"`
	// 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
	Status *IngressStatus `json:"status,omitempty"`
}

func (*Ingress) DeepCopy 

func (in *Ingress) DeepCopy() *Ingress

func (*Ingress) DeepCopyInto 

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

func (*Ingress) DeepCopyObject 

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

type IngressBackend 

type IngressBackend struct {
	// service references a service as a backend.
	// This is a mutually exclusive setting with "Resource".
	Service *IngressServiceBackend `json:"service,omitempty"`
	// 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".
	Resource *corev1.TypedLocalObjectReference `json:"resource,omitempty"`
}

func (*IngressBackend) DeepCopy 

func (in *IngressBackend) DeepCopy() *IngressBackend

func (*IngressBackend) DeepCopyInto 

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

type IngressClass 

type IngressClass struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`
	// 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
	Spec *IngressClassSpec `json:"spec,omitempty"`
}

func (*IngressClass) DeepCopy 

func (in *IngressClass) DeepCopy() *IngressClass

func (*IngressClass) DeepCopyInto 

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

func (*IngressClass) DeepCopyObject 

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

type IngressClassList 

type IngressClassList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []IngressClass `json:"items"`
}

func (*IngressClassList) DeepCopy 

func (in *IngressClassList) DeepCopy() *IngressClassList

func (*IngressClassList) DeepCopyInto 

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

func (*IngressClassList) DeepCopyObject 

func (in *IngressClassList) DeepCopyObject() 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.
	APIGroup string `json:"apiGroup,omitempty"`
	// kind is the type of resource being referenced.
	Kind string `json:"kind"`
	// name is the name of resource being referenced.
	Name string `json:"name"`
	// scope represents if this refers to a cluster or namespace scoped resource.
	// This may be set to "Cluster" (default) or "Namespace".
	Scope string `json:"scope,omitempty"`
	// 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".
	Namespace string `json:"namespace,omitempty"`
}

func (*IngressClassParametersReference) DeepCopy 

func (in *IngressClassParametersReference) DeepCopy() *IngressClassParametersReference

func (*IngressClassParametersReference) DeepCopyInto 

func (in *IngressClassParametersReference) DeepCopyInto(out *IngressClassParametersReference)

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 `json:"controller,omitempty"`
	// 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.
	Parameters *IngressClassParametersReference `json:"parameters,omitempty"`
}

func (*IngressClassSpec) DeepCopy 

func (in *IngressClassSpec) DeepCopy() *IngressClassSpec

func (*IngressClassSpec) DeepCopyInto 

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

type IngressList 

type IngressList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []Ingress `json:"items"`
}

func (*IngressList) DeepCopy 

func (in *IngressList) DeepCopy() *IngressList

func (*IngressList) DeepCopyInto 

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

func (*IngressList) DeepCopyObject 

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

type IngressLoadBalancerIngress 

type IngressLoadBalancerIngress struct {
	// ip is set for load-balancer ingress points that are IP based.
	IP string `json:"ip,omitempty"`
	// hostname is set for load-balancer ingress points that are DNS based.
	Hostname string `json:"hostname,omitempty"`
	// ports provides information about the ports exposed by this LoadBalancer.
	Ports []IngressPortStatus `json:"ports"`
}

func (*IngressLoadBalancerIngress) DeepCopy 

func (in *IngressLoadBalancerIngress) DeepCopy() *IngressLoadBalancerIngress

func (*IngressLoadBalancerIngress) DeepCopyInto 

func (in *IngressLoadBalancerIngress) DeepCopyInto(out *IngressLoadBalancerIngress)

type IngressLoadBalancerStatus 

type IngressLoadBalancerStatus struct {
	// ingress is a list containing ingress points for the load-balancer.
	Ingress []IngressLoadBalancerIngress `json:"ingress"`
}

func (*IngressLoadBalancerStatus) DeepCopy 

func (in *IngressLoadBalancerStatus) DeepCopy() *IngressLoadBalancerStatus

func (*IngressLoadBalancerStatus) DeepCopyInto 

func (in *IngressLoadBalancerStatus) DeepCopyInto(out *IngressLoadBalancerStatus)

type IngressPortStatus 

type IngressPortStatus struct {
	// port is the port number of the ingress port.
	Port int `json:"port"`
	// protocol is the protocol of the ingress port.
	// The supported values are: "TCP", "UDP", "SCTP"
	Protocol corev1.Protocol `json:"protocol"`
	// error is to record the problem with the service port
	// The format of the error shall comply with the following rules:
	// - built-in error values shall be specified in this file and those shall use
	// CamelCase names
	// - cloud provider specific error values must have names that comply with the
	// format foo.example.com/CamelCase.
	// ---
	// The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
	Error string `json:"error,omitempty"`
}

func (*IngressPortStatus) DeepCopy 

func (in *IngressPortStatus) DeepCopy() *IngressPortStatus

func (*IngressPortStatus) DeepCopyInto 

func (in *IngressPortStatus) DeepCopyInto(out *IngressPortStatus)

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.
	Host string `json:"host,omitempty"`
	// 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.
	IngressRuleValue IngressRuleValue `json:"ingressRuleValue"`
}

func (*IngressRule) DeepCopy 

func (in *IngressRule) DeepCopy() *IngressRule

func (*IngressRule) DeepCopyInto 

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

type IngressRuleValue 

type IngressRuleValue struct {
	HTTP *HTTPIngressRuleValue `json:"http,omitempty"`
}

func (*IngressRuleValue) DeepCopy 

func (in *IngressRuleValue) DeepCopy() *IngressRuleValue

func (*IngressRuleValue) DeepCopyInto 

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

type IngressServiceBackend 

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

func (*IngressServiceBackend) DeepCopy 

func (in *IngressServiceBackend) DeepCopy() *IngressServiceBackend

func (*IngressServiceBackend) DeepCopyInto 

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

type IngressSpec 

type IngressSpec struct {
	// ingressClassName is the name of an IngressClass cluster resource. Ingress
	// controller implementations use this field to know whether they should be
	// serving this Ingress resource, by a transitive connection
	// (controller -> IngressClass -> Ingress resource). Although the
	// `kubernetes.io/ingress.class` annotation (simple constant name) was never
	// formally defined, it was widely supported by Ingress controllers to create
	// a direct binding between Ingress controller and Ingress resources. Newly
	// created Ingress resources should prefer using the field. However, even
	// though the annotation is officially deprecated, for backwards compatibility
	// reasons, ingress controllers should still honor that annotation if present.
	IngressClassName string `json:"ingressClassName,omitempty"`
	// 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.
	DefaultBackend *IngressBackend `json:"defaultBackend,omitempty"`
	// tls represents the 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.
	TLS []IngressTLS `json:"tls"`
	// rules is a list of host rules used to configure the Ingress. If unspecified,
	// or no rule matches, all traffic is sent to the default backend.
	Rules []IngressRule `json:"rules"`
}

func (*IngressSpec) DeepCopy 

func (in *IngressSpec) DeepCopy() *IngressSpec

func (*IngressSpec) DeepCopyInto 

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

type IngressStatus 

type IngressStatus struct {
	// loadBalancer contains the current status of the load-balancer.
	LoadBalancer *IngressLoadBalancerStatus `json:"loadBalancer,omitempty"`
}

func (*IngressStatus) DeepCopy 

func (in *IngressStatus) DeepCopy() *IngressStatus

func (*IngressStatus) DeepCopyInto 

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

type IngressTLS 

type IngressTLS struct {
	// hosts is 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.
	Hosts []string `json:"hosts"`
	// 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.
	SecretName string `json:"secretName,omitempty"`
}

func (*IngressTLS) DeepCopy 

func (in *IngressTLS) DeepCopy() *IngressTLS

func (*IngressTLS) DeepCopyInto 

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

type NetworkPolicy 

type NetworkPolicy struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`
	// spec represents the specification of the desired behavior for this NetworkPolicy.
	Spec *NetworkPolicySpec `json:"spec,omitempty"`
	// status represents the current state of the NetworkPolicy.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Status *NetworkPolicyStatus `json:"status,omitempty"`
}

func (*NetworkPolicy) DeepCopy 

func (in *NetworkPolicy) DeepCopy() *NetworkPolicy

func (*NetworkPolicy) DeepCopyInto 

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

func (*NetworkPolicy) DeepCopyObject 

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

type NetworkPolicyConditionReason 

type NetworkPolicyConditionReason string
const (
	NetworkPolicyConditionReasonFeatureNotSupported NetworkPolicyConditionReason = "FeatureNotSupported"
)

type NetworkPolicyConditionType 

type NetworkPolicyConditionType string
const (
	NetworkPolicyConditionTypeAccepted       NetworkPolicyConditionType = "Accepted"
	NetworkPolicyConditionTypePartialFailure NetworkPolicyConditionType = "PartialFailure"
	NetworkPolicyConditionTypeFailure        NetworkPolicyConditionType = "Failure"
)

type NetworkPolicyEgressRule 

type NetworkPolicyEgressRule struct {
	// ports is a 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.
	Ports []NetworkPolicyPort `json:"ports"`
	// to is a 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.
	To []NetworkPolicyPeer `json:"to"`
}

func (*NetworkPolicyEgressRule) DeepCopy 

func (in *NetworkPolicyEgressRule) DeepCopy() *NetworkPolicyEgressRule

func (*NetworkPolicyEgressRule) DeepCopyInto 

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

type NetworkPolicyIngressRule 

type NetworkPolicyIngressRule struct {
	// ports is a 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.
	Ports []NetworkPolicyPort `json:"ports"`
	// from is a 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.
	From []NetworkPolicyPeer `json:"from"`
}

func (*NetworkPolicyIngressRule) DeepCopy 

func (in *NetworkPolicyIngressRule) DeepCopy() *NetworkPolicyIngressRule

func (*NetworkPolicyIngressRule) DeepCopyInto 

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

type NetworkPolicyList 

type NetworkPolicyList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`
	Items           []NetworkPolicy `json:"items"`
}

func (*NetworkPolicyList) DeepCopy 

func (in *NetworkPolicyList) DeepCopy() *NetworkPolicyList

func (*NetworkPolicyList) DeepCopyInto 

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

func (*NetworkPolicyList) DeepCopyObject 

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

type NetworkPolicyPeer 

type NetworkPolicyPeer struct {
	// podSelector 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.
	PodSelector *metav1.LabelSelector `json:"podSelector,omitempty"`
	// namespaceSelector 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.
	NamespaceSelector *metav1.LabelSelector `json:"namespaceSelector,omitempty"`
	// ipBlock defines policy on a particular IPBlock. If this field is set then
	// neither of the other fields can be.
	IPBlock *IPBlock `json:"ipBlock,omitempty"`
}

func (*NetworkPolicyPeer) DeepCopy 

func (in *NetworkPolicyPeer) DeepCopy() *NetworkPolicyPeer

func (*NetworkPolicyPeer) DeepCopyInto 

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

type NetworkPolicyPort 

type NetworkPolicyPort struct {
	// protocol represents the protocol (TCP, UDP, or SCTP) which traffic must match.
	// If not specified, this field defaults to TCP.
	Protocol corev1.Protocol `json:"protocol,omitempty"`
	// port represents 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.
	Port *utilintstr.IntOrString `json:"port,omitempty"`
	// endPort indicates that the range of ports from port to endPort if set, 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.
	EndPort int `json:"endPort,omitempty"`
}

func (*NetworkPolicyPort) DeepCopy 

func (in *NetworkPolicyPort) DeepCopy() *NetworkPolicyPort

func (*NetworkPolicyPort) DeepCopyInto 

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

type NetworkPolicySpec 

type NetworkPolicySpec struct {
	// podSelector 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 `json:"podSelector"`
	// ingress is a 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)
	Ingress []NetworkPolicyIngressRule `json:"ingress"`
	// egress is a 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
	Egress []NetworkPolicyEgressRule `json:"egress"`
	// policyTypes is a 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
	PolicyTypes []PolicyType `json:"policyTypes"`
}

func (*NetworkPolicySpec) DeepCopy 

func (in *NetworkPolicySpec) DeepCopy() *NetworkPolicySpec

func (*NetworkPolicySpec) DeepCopyInto 

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

type NetworkPolicyStatus 

type NetworkPolicyStatus struct {
	// conditions holds an array of metav1.Condition that describe the state of the NetworkPolicy.
	// Current service state
	Conditions []metav1.Condition `json:"conditions"`
}

func (*NetworkPolicyStatus) DeepCopy 

func (in *NetworkPolicyStatus) DeepCopy() *NetworkPolicyStatus

func (*NetworkPolicyStatus) DeepCopyInto 

func (in *NetworkPolicyStatus) DeepCopyInto(out *NetworkPolicyStatus)

type PathType 

type PathType string
const (
	PathTypeExact                  PathType = "Exact"
	PathTypePrefix                 PathType = "Prefix"
	PathTypeImplementationSpecific PathType = "ImplementationSpecific"
)

type PolicyType 

type PolicyType string
const (
	PolicyTypeIngress PolicyType = "Ingress"
	PolicyTypeEgress  PolicyType = "Egress"
)

type ServiceBackendPort 

type ServiceBackendPort struct {
	// name is the name of the port on the Service.
	// This is a mutually exclusive setting with "Number".
	Name string `json:"name,omitempty"`
	// number is the numerical port number (e.g. 80) on the Service.
	// This is a mutually exclusive setting with "Name".
	Number int `json:"number,omitempty"`
}

func (*ServiceBackendPort) DeepCopy 

func (in *ServiceBackendPort) DeepCopy() *ServiceBackendPort

func (*ServiceBackendPort) DeepCopyInto 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.