Documentation

Index

Constants

View Source
const (
	// AddressTypeIPv4 represents an IPv4 Address.
	AddressTypeIPv4 = AddressType(api.IPv4Protocol)
	// AddressTypeIPv6 represents an IPv6 Address.
	AddressTypeIPv6 = AddressType(api.IPv6Protocol)
	// AddressTypeFQDN represents a FQDN.
	AddressTypeFQDN = AddressType("FQDN")
)
View Source
const GroupName = "discovery.k8s.io"

    GroupName is the group name used in this package

    Variables

    View Source
    var (
    	// SchemeBuilder is the scheme builder with scheme init functions to run for this API package
    	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
    	// AddToScheme is a global function that registers this API group & version to a 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 AddressType

          type AddressType string

            AddressType represents the type of address referred to by an endpoint.

            type Endpoint

            type Endpoint struct {
            	// addresses of this endpoint. The contents of this field are interpreted
            	// according to the corresponding EndpointSlice addressType field. Consumers
            	// must handle different types of addresses in the context of their own
            	// capabilities. This must contain at least one address but no more than
            	// 100.
            	// +listType=set
            	Addresses []string
            	// conditions contains information about the current status of the endpoint.
            	Conditions EndpointConditions
            	// hostname of this endpoint. This field may be used by consumers of
            	// endpoints to distinguish endpoints from each other (e.g. in DNS names).
            	// Multiple endpoints which use the same hostname should be considered
            	// fungible (e.g. multiple A values in DNS). Must pass DNS Label (RFC 1123)
            	// validation.
            	// +optional
            	Hostname *string
            	// targetRef is a reference to a Kubernetes object that represents this
            	// endpoint.
            	// +optional
            	TargetRef *api.ObjectReference
            	// topology contains arbitrary topology information associated with the
            	// endpoint. These key/value pairs must conform with the label format.
            	// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels
            	// Topology may include a maximum of 16 key/value pairs. This includes, but
            	// is not limited to the following well known keys:
            	// * kubernetes.io/hostname: the value indicates the hostname of the node
            	//   where the endpoint is located. This should match the corresponding
            	//   node label.
            	// * topology.kubernetes.io/zone: the value indicates the zone where the
            	//   endpoint is located. This should match the corresponding node label.
            	// * topology.kubernetes.io/region: the value indicates the region where the
            	//   endpoint is located. This should match the corresponding node label.
            	// This field is deprecated and will be removed in future api versions.
            	// +optional
            	Topology map[string]string
            	// nodeName represents the name of the Node hosting this endpoint. This can
            	// be used to determine endpoints local to a Node. This field can be enabled
            	// with the EndpointSliceNodeName feature gate.
            	// +optional
            	NodeName *string
            }

              Endpoint represents a single logical "backend" implementing a service.

              func (*Endpoint) DeepCopy

              func (in *Endpoint) DeepCopy() *Endpoint

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

                func (*Endpoint) DeepCopyInto

                func (in *Endpoint) DeepCopyInto(out *Endpoint)

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

                  type EndpointConditions

                  type EndpointConditions struct {
                  	// ready indicates that this endpoint is prepared to receive traffic,
                  	// according to whatever system is managing the endpoint. A nil value
                  	// indicates an unknown state. In most cases consumers should interpret this
                  	// unknown state as ready. For compatibility reasons, ready should never be
                  	// "true" for terminating endpoints.
                  	Ready *bool
                  
                  	// serving is identical to ready except that it is set regardless of the
                  	// terminating state of endpoints. This condition should be set to true for
                  	// a ready endpoint that is terminating. If nil, consumers should defer to
                  	// the ready condition. This field can be enabled with the
                  	// EndpointSliceTerminatingCondition feature gate.
                  	// +optional
                  	Serving *bool
                  
                  	// terminating indicates that this endpoint is terminating. A nil value
                  	// indicates an unknown state. Consumers should interpret this unknown state
                  	// to mean that the endpoint is not terminating. This field can be enabled
                  	// with the EndpointSliceTerminatingCondition feature gate.
                  	// +optional
                  	Terminating *bool
                  }

                    EndpointConditions represents the current condition of an endpoint.

                    func (*EndpointConditions) DeepCopy

                    func (in *EndpointConditions) DeepCopy() *EndpointConditions

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

                      func (*EndpointConditions) DeepCopyInto

                      func (in *EndpointConditions) DeepCopyInto(out *EndpointConditions)

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

                        type EndpointPort

                        type EndpointPort struct {
                        	// The name of this port. All ports in an EndpointSlice must have a unique
                        	// name. If the EndpointSlice is dervied from a Kubernetes service, this
                        	// corresponds to the Service.ports[].name.
                        	// Name must either be an empty string or pass DNS_LABEL validation:
                        	// * must be no more than 63 characters long.
                        	// * must consist of lower case alphanumeric characters or '-'.
                        	// * must start and end with an alphanumeric character.
                        	Name *string
                        	// The IP protocol for this port.
                        	// Must be UDP, TCP, or SCTP.
                        	Protocol *api.Protocol
                        	// The port number of the endpoint.
                        	// If this is not specified, ports are not restricted and must be
                        	// interpreted in the context of the specific consumer.
                        	Port *int32
                        	// The application protocol for this port.
                        	// This field follows standard Kubernetes label syntax.
                        	// Un-prefixed names are reserved for IANA standard service names (as per
                        	// RFC-6335 and http://www.iana.org/assignments/service-names).
                        	// Non-standard protocols should use prefixed names such as
                        	// mycompany.com/my-custom-protocol.
                        	// +optional
                        	AppProtocol *string
                        }

                          EndpointPort represents a Port used by an EndpointSlice.

                          func (*EndpointPort) DeepCopy

                          func (in *EndpointPort) DeepCopy() *EndpointPort

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

                            func (*EndpointPort) DeepCopyInto

                            func (in *EndpointPort) DeepCopyInto(out *EndpointPort)

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

                              type EndpointSlice

                              type EndpointSlice struct {
                              	metav1.TypeMeta
                              	// Standard object's metadata.
                              	// +optional
                              	metav1.ObjectMeta
                              	// addressType specifies the type of address carried by this EndpointSlice.
                              	// All addresses in this slice must be the same type. This field is
                              	// immutable after creation. The following address types are currently
                              	// supported:
                              	// * IPv4: Represents an IPv4 Address.
                              	// * IPv6: Represents an IPv6 Address.
                              	// * FQDN: Represents a Fully Qualified Domain Name.
                              	AddressType AddressType
                              	// endpoints is a list of unique endpoints in this slice. Each slice may
                              	// include a maximum of 1000 endpoints.
                              	// +listType=atomic
                              	Endpoints []Endpoint
                              	// ports specifies the list of network ports exposed by each endpoint in
                              	// this slice. Each port must have a unique name. When ports is empty, it
                              	// indicates that there are no defined ports. When a port is defined with a
                              	// nil port value, it indicates "all ports". Each slice may include a
                              	// maximum of 100 ports.
                              	// +optional
                              	// +listType=atomic
                              	Ports []EndpointPort
                              }

                                EndpointSlice represents a subset of the endpoints that implement a service. For a given service there may be multiple EndpointSlice objects, selected by labels, which must be joined to produce the full set of endpoints.

                                func (*EndpointSlice) DeepCopy

                                func (in *EndpointSlice) DeepCopy() *EndpointSlice

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

                                  func (*EndpointSlice) DeepCopyInto

                                  func (in *EndpointSlice) DeepCopyInto(out *EndpointSlice)

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

                                    func (*EndpointSlice) DeepCopyObject

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

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

                                      type EndpointSliceList

                                      type EndpointSliceList struct {
                                      	metav1.TypeMeta
                                      	// Standard list metadata.
                                      	// +optional
                                      	metav1.ListMeta
                                      	// List of endpoint slices
                                      	Items []EndpointSlice
                                      }

                                        EndpointSliceList represents a list of endpoint slices.

                                        func (*EndpointSliceList) DeepCopy

                                        func (in *EndpointSliceList) DeepCopy() *EndpointSliceList

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

                                          func (*EndpointSliceList) DeepCopyInto

                                          func (in *EndpointSliceList) DeepCopyInto(out *EndpointSliceList)

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

                                            func (*EndpointSliceList) DeepCopyObject

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

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

                                              Directories

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