apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: kibanas.kibana.k8s.elastic.co
spec:
  group: kibana.k8s.elastic.co
  names:
    categories:
    - elastic
    kind: Kibana
    listKind: KibanaList
    plural: kibanas
    shortNames:
    - kb
    singular: kibana
  scope: Namespaced
  versions:
  - name: v1
    served: true
    storage: true
    schema:
      openAPIV3Schema:
        type: object
        description: Kibana represents a Kibana resource in a Kubernetes cluster.
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this representation
              of an object. Servers should convert recognized schemas to the latest
              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this
              object represents. Servers may infer this from the endpoint the client
              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: KibanaSpec holds the specification of a Kibana instance.
            properties:
              config:
                description: 'Config holds the Kibana configuration. See: https://www.elastic.co/guide/en/kibana/current/settings.html'
                type: object
              count:
                description: Count of Kibana instances to deploy.
                format: int32
                type: integer
              elasticsearchRef:
                description: ElasticsearchRef is a reference to an Elasticsearch cluster
                  running in the same Kubernetes cluster.
                properties:
                  name:
                    description: Name of the Kubernetes object.
                    type: string
                  namespace:
                    description: Namespace of the Kubernetes object. If empty, defaults
                      to the current namespace.
                    type: string
                required:
                - name
                type: object
              http:
                description: HTTP holds the HTTP layer configuration for Kibana.
                properties:
                  service:
                    description: Service defines the template for the associated Kubernetes
                      Service object.
                    properties:
                      metadata:
                        description: ObjectMeta is the metadata of the service. The
                          name and namespace provided here are managed by ECK and will
                          be ignored.
                        type: object
                      spec:
                        description: Spec is the specification of the service.
                        properties:
                          clusterIP:
                            description: 'clusterIP is the IP address of the service
                              and is usually assigned randomly by the master. If an
                              address is specified manually and is not in use by others,
                              it will be allocated to the service; otherwise, creation
                              of the service will fail. This field can not be changed
                              through updates. Valid values are "None", empty string
                              (""), or a valid IP address. "None" can be specified for
                              headless services when proxying is not required. Only
                              applies to types ClusterIP, NodePort, and LoadBalancer.
                              Ignored if type is ExternalName. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies'
                            type: string
                          externalIPs:
                            description: 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.
                            items:
                              type: string
                            type: array
                          externalName:
                            description: externalName is the external reference that
                              kubedns or equivalent will return as a CNAME record for
                              this service. No proxying will be involved. Must be a
                              valid RFC-1123 hostname (https://tools.ietf.org/html/rfc1123)
                              and requires Type to be ExternalName.
                            type: string
                          externalTrafficPolicy:
                            description: externalTrafficPolicy denotes if this Service
                              desires to route external traffic to node-local or cluster-wide
                              endpoints. "Local" preserves the client source IP and
                              avoids a second hop for LoadBalancer and Nodeport type
                              services, but risks potentially imbalanced traffic spreading.
                              "Cluster" obscures the client source IP and may cause
                              a second hop to another node, but should have good overall
                              load-spreading.
                            type: string
                          healthCheckNodePort:
                            description: healthCheckNodePort specifies the healthcheck
                              nodePort for the service. If not specified, HealthCheckNodePort
                              is created by the service api backend with the allocated
                              nodePort. Will use user-specified nodePort value if specified
                              by the client. Only effects when Type is set to LoadBalancer
                              and ExternalTrafficPolicy is set to Local.
                            format: int32
                            type: integer
                          ipFamily:
                            description: ipFamily specifies whether this Service has
                              a preference for a particular IP family (e.g. IPv4 vs.
                              IPv6).  If a specific IP family is requested, the clusterIP
                              field will be allocated from that family, if it is available
                              in the cluster.  If no IP family is requested, the cluster's
                              primary IP family will be used. Other IP fields (loadBalancerIP,
                              loadBalancerSourceRanges, externalIPs) and controllers
                              which allocate external load-balancers should use the
                              same IP family.  Endpoints for this Service will be of
                              this family.  This field is immutable after creation.
                              Assigning a ServiceIPFamily not available in the cluster
                              (e.g. IPv6 in IPv4 only cluster) is an error condition
                              and will fail during clusterIP assignment.
                            type: string
                          loadBalancerIP:
                            description: 'Only applies to Service Type: LoadBalancer
                              LoadBalancer will get created with the IP specified in
                              this field. 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.'
                            type: string
                          loadBalancerSourceRanges:
                            description: 'If specified and supported by the platform,
                              this will restrict traffic through the cloud-provider
                              load-balancer will be restricted to the specified client
                              IPs. This field will be ignored if the cloud-provider
                              does not support the feature." More info: https://kubernetes.io/docs/tasks/access-application-cluster/configure-cloud-provider-firewall/'
                            items:
                              type: string
                            type: array
                          ports:
                            description: 'The list of ports that are exposed by this
                              service. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies'
                            items:
                              description: ServicePort contains information on service's
                                port.
                              properties:
                                name:
                                  description: The name of this port within the service.
                                    This must be a DNS_LABEL. All ports within a ServiceSpec
                                    must have unique names. When considering the endpoints
                                    for a Service, this must match the 'name' field
                                    in the EndpointPort. Optional if only one ServicePort
                                    is defined on this service.
                                  type: string
                                nodePort:
                                  description: 'The port on each node on which this
                                    service is exposed when type=NodePort or LoadBalancer.
                                    Usually assigned by the system. If specified, it
                                    will be allocated to the service if unused or else
                                    creation of the service will fail. Default is to
                                    auto-allocate a port if the ServiceType of this
                                    Service requires one. More info: https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport'
                                  format: int32
                                  type: integer
                                port:
                                  description: The port that will be exposed by this
                                    service.
                                  format: int32
                                  type: integer
                                protocol:
                                  description: The IP protocol for this port. Supports
                                    "TCP", "UDP", and "SCTP". Default is TCP.
                                  type: string
                                targetPort:
                                  x-kubernetes-int-or-string: true
                                  anyOf:
                                    - type: integer
                                    - type: string
                                  description: 'Number or name of the port to access
                                    on the pods targeted by the service. Number must
                                    be in the range 1 to 65535. Name must be an IANA_SVC_NAME.
                                    If this is a string, it will be looked up as a named
                                    port in the target Pod''s container ports. If this
                                    is not specified, the value of the ''port'' field
                                    is used (an identity map). This field is ignored
                                    for services with clusterIP=None, and should be
                                    omitted or set equal to the ''port'' field. More
                                    info: https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service'
                              required:
                              - port
                              type: object
                            type: array
                          publishNotReadyAddresses:
                            description: publishNotReadyAddresses, when set to true,
                              indicates that DNS implementations must publish the notReadyAddresses
                              of subsets for the Endpoints associated with the Service.
                              The default value is false. The primary use case for setting
                              this field is to use a StatefulSet's Headless Service
                              to propagate SRV records for its Pods without respect
                              to their readiness for purpose of peer discovery.
                            type: boolean
                          selector:
                            additionalProperties:
                              type: string
                            description: '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/'
                            type: object
                          sessionAffinity:
                            description: 'Supports "ClientIP" and "None". Used to maintain
                              session affinity. Enable client IP based session affinity.
                              Must be ClientIP or None. Defaults to None. More info:
                              https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies'
                            type: string
                          sessionAffinityConfig:
                            description: sessionAffinityConfig contains the configurations
                              of session affinity.
                            properties:
                              clientIP:
                                description: clientIP contains the configurations of
                                  Client IP based session affinity.
                                properties:
                                  timeoutSeconds:
                                    description: timeoutSeconds specifies the seconds
                                      of ClientIP type session sticky time. The value
                                      must be >0 && <=86400(for 1 day) if ServiceAffinity
                                      == "ClientIP". Default value is 10800(for 3 hours).
                                    format: int32
                                    type: integer
                                type: object
                            type: object
                          type:
                            description: 'type determines how the Service is exposed.
                              Defaults to ClusterIP. Valid options are ExternalName,
                              ClusterIP, NodePort, and LoadBalancer. "ExternalName"
                              maps to the specified externalName. "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. If clusterIP is "None", no virtual IP is allocated
                              and the endpoints are published as a set of endpoints
                              rather than a stable IP. "NodePort" builds on ClusterIP
                              and allocates a port on every node which routes to the
                              clusterIP. "LoadBalancer" builds on NodePort and creates
                              an external load-balancer (if supported in the current
                              cloud) which routes to the clusterIP. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types'
                            type: string
                        type: object
                    type: object
                  tls:
                    description: TLS defines options for configuring TLS for HTTP.
                    properties:
                      certificate:
                        description: "Certificate is a reference to a Kubernetes secret
                          that contains the certificate and private key for enabling
                          TLS. The referenced secret should contain the following: \n
                          - `ca.crt`: The certificate authority (optional). - `tls.crt`:
                          The certificate (or a chain). - `tls.key`: The private key
                          to the first certificate in the certificate chain."
                        properties:
                          secretName:
                            description: SecretName is the name of the secret.
                            type: string
                        type: object
                      selfSignedCertificate:
                        description: SelfSignedCertificate allows configuring the self-signed
                          certificate generated by the operator.
                        properties:
                          disabled:
                            description: Disabled indicates that the provisioning of
                              the self-signed certifcate should be disabled.
                            type: boolean
                          subjectAltNames:
                            description: SubjectAlternativeNames is a list of SANs to
                              include in the generated HTTP TLS certificate.
                            items:
                              description: SubjectAlternativeName represents a SAN entry
                                in a x509 certificate.
                              properties:
                                dns:
                                  description: DNS is the DNS name of the subject.
                                  type: string
                                ip:
                                  description: IP is the IP address of the subject.
                                  type: string
                              type: object
                            type: array
                        type: object
                    type: object
                type: object
              image:
                description: Image is the Kibana Docker image to deploy.
                type: string
              podTemplate:
                description: PodTemplate provides customisation options (labels, annotations,
                  affinity rules, resource requests, and so on) for the Kibana pods
                type: object
              secureSettings:
                description: 'SecureSettings is a list of references to Kubernetes secrets
                  containing sensitive configuration options for Kibana. See: https://www.elastic.co/guide/en/cloud-on-k8s/current/k8s-kibana.html#k8s-kibana-secure-settings'
                items:
                  description: SecretSource defines a data source based on a Kubernetes
                    Secret.
                  properties:
                    entries:
                      description: Entries define how to project each key-value pair
                        in the secret to filesystem paths. If not defined, all keys
                        will be projected to similarly named paths in the filesystem.
                        If defined, only the specified keys will be projected to the
                        corresponding paths.
                      items:
                        description: KeyToPath defines how to map a key in a Secret
                          object to a filesystem path.
                        properties:
                          key:
                            description: Key is the key contained in the secret.
                            type: string
                          path:
                            description: Path is the relative file path to map the key
                              to. Path must not be an absolute file path and must not
                              contain any ".." components.
                            type: string
                        required:
                        - key
                        type: object
                      type: array
                    secretName:
                      description: SecretName is the name of the secret.
                      type: string
                  required:
                  - secretName
                  type: object
                type: array
              version:
                description: Version of Kibana.
                type: string
            type: object
          status:
            description: KibanaStatus defines the observed state of Kibana
            properties:
              associationStatus:
                description: AssociationStatus is the status of an association resource.
                type: string
              availableNodes:
                format: int32
                type: integer
              health:
                description: KibanaHealth expresses the status of the Kibana instances.
                type: string
            type: object
status:
  acceptedNames:
    kind: ""
    plural: ""
  conditions: []
  storedVersions: []