Class V1ServiceSpec
ServiceSpec describes the attributes that a user creates on a service.
Inheritance
V1ServiceSpec
Assembly: KubernetesClient.dll
Syntax
public record V1ServiceSpec : IEquatable<V1ServiceSpec>
Constructors
View Source
V1ServiceSpec()
Declaration
View Source
V1ServiceSpec(V1ServiceSpec)
Declaration
protected V1ServiceSpec(V1ServiceSpec original)
Parameters
Properties
View Source
AllocateLoadBalancerNodePorts
allocateLoadBalancerNodePorts defines if NodePorts will be automatically
allocated for services with type LoadBalancer. Default is "true". It may be set
to "false" if the cluster load-balancer does not rely on NodePorts. If the
caller requests specific NodePorts (by specifying a value), those requests will
be respected, regardless of this field. This field may only be set for services
with type LoadBalancer and will be cleared if the type is changed to any other
type.
Declaration
[JsonPropertyName("allocateLoadBalancerNodePorts")]
public bool? AllocateLoadBalancerNodePorts { get; set; }
Property Value
View Source
ClusterIP
clusterIP is the IP address of the service and is usually assigned randomly. If
an address is specified manually, is in-range (as per system configuration), and
is not in use, it will be allocated to the service; otherwise creation of the
service will fail. This field may not be changed through updates unless the type
field is also being changed to ExternalName (which requires this field to be
blank) or the type field is being changed from ExternalName (in which case this
field may optionally be specified, as describe above). Valid values are "None",
empty string (" "), or a valid IP address. Setting this to "None" makes a
"headless service" (no virtual IP), which is useful when direct endpoint
connections are preferred and proxying is not required. Only applies to types
ClusterIP, NodePort, and LoadBalancer. If this field is specified when creating
a Service of type ExternalName, creation will fail. This field will be wiped
when updating a Service to type ExternalName. More info:
https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
Declaration
[JsonPropertyName("clusterIP")]
public string ClusterIP { get; set; }
Property Value
View Source
ClusterIPs
ClusterIPs is a list of IP addresses assigned to this service, and are usually
assigned randomly. If an address is specified manually, is in-range (as per
system configuration), and is not in use, it will be allocated to the service;
otherwise creation of the service will fail. This field may not be changed
through updates unless the type field is also being changed to ExternalName
(which requires this field to be empty) or the type field is being changed from
ExternalName (in which case this field may optionally be specified, as describe
above). Valid values are "None", empty string (" "), or a valid IP address.
Setting this to "None" makes a "headless service" (no virtual IP), which is
useful when direct endpoint connections are preferred and proxying is not
required. Only applies to types ClusterIP, NodePort, and LoadBalancer. If this
field is specified when creating a Service of type ExternalName, creation will
fail. This field will be wiped when updating a Service to type ExternalName. If
this field is not specified, it will be initialized from the clusterIP field.
If this field is specified, clients must ensure that clusterIPs[0] and clusterIP
have the same value.
This field may hold a maximum of two entries (dual-stack IPs, in either order).
These IPs must correspond to the values of the ipFamilies field. Both clusterIPs
and ipFamilies are governed by the ipFamilyPolicy field. More info:
https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
Declaration
[JsonPropertyName("clusterIPs")]
public IList<string> ClusterIPs { get; set; }
Property Value
View Source
EqualityContract
Declaration
protected virtual Type EqualityContract { get; }
Property Value
View Source
ExternalIPs
externalIPs is a list of IP addresses for which nodes in the cluster will also
accept traffic for this service. These IPs are not managed by Kubernetes. The
user is responsible for ensuring that traffic arrives at a node with this IP. A
common example is external load-balancers that are not part of the Kubernetes
system.
Declaration
[JsonPropertyName("externalIPs")]
public IList<string> ExternalIPs { get; set; }
Property Value
View Source
ExternalName
externalName is the external reference that discovery mechanisms will return as
an alias for this service (e.g. a DNS CNAME record). No proxying will be
involved. Must be a lowercase RFC-1123 hostname
(https://tools.ietf.org/html/rfc1123) and requires type to be "ExternalName".
Declaration
[JsonPropertyName("externalName")]
public string ExternalName { get; set; }
Property Value
View Source
ExternalTrafficPolicy
externalTrafficPolicy describes how nodes distribute service traffic they
receive on one of the Service's "externally-facing" addresses (NodePorts,
ExternalIPs, and LoadBalancer IPs). If set to "Local", the proxy will configure
the service in a way that assumes that external load balancers will take care of
balancing the service traffic between nodes, and so each node will deliver
traffic only to the node-local endpoints of the service, without masquerading
the client source IP. (Traffic mistakenly sent to a node with no endpoints will
be dropped.) The default value, "Cluster", uses the standard behavior of routing
to all endpoints evenly (possibly modified by topology and other features). Note
that traffic sent to an External IP or LoadBalancer IP from within the cluster
will always get "Cluster" semantics, but clients sending to a NodePort from
within the cluster may need to take traffic policy into account when picking a
node.
Declaration
[JsonPropertyName("externalTrafficPolicy")]
public string ExternalTrafficPolicy { get; set; }
Property Value
View Source
HealthCheckNodePort
healthCheckNodePort specifies the healthcheck nodePort for the service. This
only applies when type is set to LoadBalancer and externalTrafficPolicy is set
to Local. If a value is specified, is in-range, and is not in use, it will be
used. If not specified, a value will be automatically allocated. External
systems (e.g. load-balancers) can use this port to determine if a given node
holds endpoints for this service or not. If this field is specified when
creating a Service which does not need it, creation will fail. This field will
be wiped when updating a Service to no longer need it (e.g. changing type). This
field cannot be updated once set.
Declaration
[JsonPropertyName("healthCheckNodePort")]
public int? HealthCheckNodePort { get; set; }
Property Value
View Source
InternalTrafficPolicy
InternalTrafficPolicy describes how nodes distribute service traffic they
receive on the ClusterIP. If set to "Local", the proxy will assume that pods
only want to talk to endpoints of the service on the same node as the pod,
dropping the traffic if there are no local endpoints. The default value,
"Cluster", uses the standard behavior of routing to all endpoints evenly
(possibly modified by topology and other features).
Declaration
[JsonPropertyName("internalTrafficPolicy")]
public string InternalTrafficPolicy { get; set; }
Property Value
View Source
IpFamilies
IPFamilies is a list of IP families (e.g. IPv4, IPv6) assigned to this service.
This field is usually assigned automatically based on cluster configuration and
the ipFamilyPolicy field. If this field is specified manually, the requested
family is available in the cluster, and ipFamilyPolicy allows it, it will be
used; otherwise creation of the service will fail. This field is conditionally
mutable: it allows for adding or removing a secondary IP family, but it does not
allow changing the primary IP family of the Service. Valid values are "IPv4" and
"IPv6". This field only applies to Services of types ClusterIP, NodePort, and
LoadBalancer, and does apply to "headless" services. This field will be wiped
when updating a Service to type ExternalName.
This field may hold a maximum of two entries (dual-stack families, in either
order). These families must correspond to the values of the clusterIPs field,
if specified. Both clusterIPs and ipFamilies are governed by the ipFamilyPolicy
field.
Declaration
[JsonPropertyName("ipFamilies")]
public IList<string> IpFamilies { get; set; }
Property Value
View Source
IpFamilyPolicy
IPFamilyPolicy represents the dual-stack-ness requested or required by this
Service. If there is no value provided, then this field will be set to
SingleStack. Services can be "SingleStack" (a single IP family),
"PreferDualStack" (two IP families on dual-stack configured clusters or a single
IP family on single-stack clusters), or "RequireDualStack" (two IP families on
dual-stack configured clusters, otherwise fail). The ipFamilies and clusterIPs
fields depend on the value of this field. This field will be wiped when updating
a service to type ExternalName.
Declaration
[JsonPropertyName("ipFamilyPolicy")]
public string IpFamilyPolicy { get; set; }
Property Value
View Source
LoadBalancerClass
loadBalancerClass is the class of the load balancer implementation this Service
belongs to. If specified, the value of this field must be a label-style
identifier, with an optional prefix, e.g. "internal-vip" or
"example.com/internal-vip". Unprefixed names are reserved for end-users. This
field can only be set when the Service type is 'LoadBalancer'. If not set, the
default load balancer implementation is used, today this is typically done
through the cloud provider integration, but should apply for any default
implementation. If set, it is assumed that a load balancer implementation is
watching for Services with a matching class. Any default load balancer
implementation (e.g. cloud providers) should ignore Services that set this
field. This field can only be set when creating or updating a Service to type
'LoadBalancer'. Once set, it can not be changed. This field will be wiped when a
service is updated to a non 'LoadBalancer' type.
Declaration
[JsonPropertyName("loadBalancerClass")]
public string LoadBalancerClass { get; set; }
Property Value
View Source
LoadBalancerIP
Only applies to Service Type: LoadBalancer. This feature depends on whether the
underlying cloud-provider supports specifying the loadBalancerIP when a load
balancer is created. This field will be ignored if the cloud-provider does not
support the feature. Deprecated: This field was under-specified and its meaning
varies across implementations. Using it is non-portable and it may not support
dual-stack. Users are encouraged to use implementation-specific annotations when
available.
Declaration
[JsonPropertyName("loadBalancerIP")]
public string LoadBalancerIP { get; set; }
Property Value
View Source
LoadBalancerSourceRanges
Declaration
[JsonPropertyName("loadBalancerSourceRanges")]
public IList<string> LoadBalancerSourceRanges { get; set; }
Property Value
View Source
Ports
Declaration
[JsonPropertyName("ports")]
public IList<V1ServicePort> Ports { get; set; }
Property Value
View Source
PublishNotReadyAddresses
publishNotReadyAddresses indicates that any agent which deals with endpoints for
this Service should disregard any indications of ready/not-ready. The primary
use case for setting this field is for a StatefulSet's Headless Service to
propagate SRV DNS records for its Pods for the purpose of peer discovery. The
Kubernetes controllers that generate Endpoints and EndpointSlice resources for
Services interpret this to mean that all endpoints are considered "ready" even
if the Pods themselves are not. Agents which consume only Kubernetes generated
endpoints through the Endpoints or EndpointSlice resources can safely assume
this behavior.
Declaration
[JsonPropertyName("publishNotReadyAddresses")]
public bool? PublishNotReadyAddresses { get; set; }
Property Value
View Source
Selector
Route service traffic to pods with label keys and values matching this selector.
If empty or not present, the service is assumed to have an external process
managing its endpoints, which Kubernetes will not modify. Only applies to types
ClusterIP, NodePort, and LoadBalancer. Ignored if type is ExternalName. More
info: https://kubernetes.io/docs/concepts/services-networking/service/
Declaration
[JsonPropertyName("selector")]
public IDictionary<string, string> Selector { get; set; }
Property Value
View Source
SessionAffinity
Declaration
[JsonPropertyName("sessionAffinity")]
public string SessionAffinity { get; set; }
Property Value
View Source
SessionAffinityConfig
sessionAffinityConfig contains the configurations of session affinity.
Declaration
[JsonPropertyName("sessionAffinityConfig")]
public V1SessionAffinityConfig SessionAffinityConfig { get; set; }
Property Value
View Source
TrafficDistribution
TrafficDistribution offers a way to express preferences for how traffic is
distributed to Service endpoints. Implementations can use this field as a hint,
but are not required to guarantee strict adherence. If the field is not set, the
implementation will apply its default routing strategy. If set to "PreferClose",
implementations should prioritize endpoints that are in the same zone.
Declaration
[JsonPropertyName("trafficDistribution")]
public string TrafficDistribution { get; set; }
Property Value
View Source
Type
type determines how the Service is exposed. Defaults to ClusterIP. Valid options
are ExternalName, ClusterIP, NodePort, and LoadBalancer. "ClusterIP" allocates a
cluster-internal IP address for load-balancing to endpoints. Endpoints are
determined by the selector or if that is not specified, by manual construction
of an Endpoints object or EndpointSlice objects. If clusterIP is "None", no
virtual IP is allocated and the endpoints are published as a set of endpoints
rather than a virtual IP. "NodePort" builds on ClusterIP and allocates a port on
every node which routes to the same endpoints as the clusterIP. "LoadBalancer"
builds on NodePort and creates an external load-balancer (if supported in the
current cloud) which routes to the same endpoints as the clusterIP.
"ExternalName" aliases this service to the specified externalName. Several other
fields do not apply to ExternalName services. More info:
https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
Declaration
[JsonPropertyName("type")]
public string Type { get; set; }
Property Value
Methods
View Source
Equals(object?)
Declaration
public override bool Equals(object? obj)
Parameters
| Type |
Name |
Description |
| object |
obj |
|
Returns
Overrides
View Source
Equals(V1ServiceSpec?)
Declaration
public virtual bool Equals(V1ServiceSpec? other)
Parameters
Returns
View Source
GetHashCode()
Declaration
public override int GetHashCode()
Returns
Overrides
View Source
PrintMembers(StringBuilder)
Declaration
protected virtual bool PrintMembers(StringBuilder builder)
Parameters
Returns
View Source
ToString()
Declaration
public override string ToString()
Returns
Overrides
Operators
View Source
operator ==(V1ServiceSpec?, V1ServiceSpec?)
Declaration
public static bool operator ==(V1ServiceSpec? left, V1ServiceSpec? right)
Parameters
Returns
View Source
operator !=(V1ServiceSpec?, V1ServiceSpec?)
Declaration
public static bool operator !=(V1ServiceSpec? left, V1ServiceSpec? right)
Parameters
Returns
Implements