kafkaconnect_v1alpha1.json

{
  "description": "KafkaConnect is the Schema for the kafkaconnects API",
  "properties": {
    "apiVersion": {
      "description": "APIVersion defines the versioned schema of this representation of an object.\nServers should convert recognized schemas to the latest internal value, and\nmay reject unrecognized values.\nMore 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.\nServers may infer this from the endpoint the client submits requests to.\nCannot be updated.\nIn CamelCase.\nMore info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds",
      "type": "string"
    },
    "metadata": {
      "type": "object"
    },
    "spec": {
      "description": "KafkaConnectSpec defines the desired state of KafkaConnect",
      "properties": {
        "authSecretRef": {
          "description": "Authentication reference to Aiven token in a secret",
          "properties": {
            "key": {
              "minLength": 1,
              "type": "string"
            },
            "name": {
              "minLength": 1,
              "type": "string"
            }
          },
          "required": [
            "key",
            "name"
          ],
          "type": "object",
          "additionalProperties": false
        },
        "cloudName": {
          "description": "Cloud the service runs in.",
          "maxLength": 256,
          "type": "string"
        },
        "maintenanceWindowDow": {
          "description": "Day of week when maintenance operations should be performed. One monday, tuesday, wednesday, etc.",
          "enum": [
            "monday",
            "tuesday",
            "wednesday",
            "thursday",
            "friday",
            "saturday",
            "sunday"
          ],
          "type": "string"
        },
        "maintenanceWindowTime": {
          "description": "Time of day when maintenance operations should be performed. UTC time in HH:mm:ss format.",
          "maxLength": 8,
          "type": "string"
        },
        "plan": {
          "description": "Subscription plan.",
          "maxLength": 128,
          "type": "string"
        },
        "project": {
          "description": "Identifies the project this resource belongs to",
          "maxLength": 63,
          "pattern": "^[a-zA-Z0-9_-]+$",
          "type": "string",
          "x-kubernetes-validations": [
            {
              "message": "Value is immutable",
              "rule": "self == oldSelf"
            }
          ]
        },
        "projectVPCRef": {
          "description": "ProjectVPCRef reference to ProjectVPC resource to use its ID as ProjectVPCID automatically",
          "properties": {
            "name": {
              "minLength": 1,
              "type": "string"
            },
            "namespace": {
              "minLength": 1,
              "type": "string"
            }
          },
          "required": [
            "name"
          ],
          "type": "object",
          "additionalProperties": false
        },
        "projectVpcId": {
          "description": "Identifier of the VPC the service should be in, if any.",
          "maxLength": 36,
          "type": "string"
        },
        "serviceIntegrations": {
          "description": "Service integrations to specify when creating a service. Not applied after initial service creation",
          "items": {
            "description": "Service integrations to specify when creating a service. Not applied after initial service creation",
            "properties": {
              "integrationType": {
                "enum": [
                  "read_replica"
                ],
                "type": "string"
              },
              "sourceServiceName": {
                "maxLength": 64,
                "minLength": 1,
                "type": "string"
              }
            },
            "required": [
              "integrationType",
              "sourceServiceName"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "maxItems": 1,
          "type": "array",
          "x-kubernetes-validations": [
            {
              "message": "Value is immutable",
              "rule": "self == oldSelf"
            }
          ]
        },
        "tags": {
          "additionalProperties": {
            "type": "string"
          },
          "description": "Tags are key-value pairs that allow you to categorize services.",
          "type": "object"
        },
        "technicalEmails": {
          "description": "Defines the email addresses that will receive alerts about upcoming maintenance updates or warnings about service instability.",
          "items": {
            "properties": {
              "email": {
                "description": "Email address.",
                "pattern": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
                "type": "string"
              }
            },
            "required": [
              "email"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "maxItems": 10,
          "type": "array"
        },
        "terminationProtection": {
          "description": "Prevent service from being deleted. It is recommended to have this enabled for all services.",
          "type": "boolean"
        },
        "userConfig": {
          "description": "KafkaConnect specific user configuration options",
          "properties": {
            "additional_backup_regions": {
              "description": "Deprecated. Additional Cloud Regions for Backup Replication",
              "items": {
                "type": "string"
              },
              "maxItems": 1,
              "type": "array"
            },
            "ip_filter": {
              "description": "Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'",
              "items": {
                "description": "CIDR address block, either as a string, or in a dict with an optional description field",
                "properties": {
                  "description": {
                    "description": "Description for IP filter list entry",
                    "maxLength": 1024,
                    "type": "string"
                  },
                  "network": {
                    "description": "CIDR address block",
                    "maxLength": 43,
                    "type": "string"
                  }
                },
                "required": [
                  "network"
                ],
                "type": "object",
                "additionalProperties": false
              },
              "maxItems": 1024,
              "type": "array"
            },
            "kafka_connect": {
              "description": "Kafka Connect configuration values",
              "properties": {
                "connector_client_config_override_policy": {
                  "description": "Defines what client configurations can be overridden by the connector. Default is None",
                  "enum": [
                    "None",
                    "All"
                  ],
                  "type": "string"
                },
                "consumer_auto_offset_reset": {
                  "description": "What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest",
                  "enum": [
                    "earliest",
                    "latest"
                  ],
                  "type": "string"
                },
                "consumer_fetch_max_bytes": {
                  "description": "Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.",
                  "maximum": 104857600,
                  "minimum": 1048576,
                  "type": "integer"
                },
                "consumer_isolation_level": {
                  "description": "Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.",
                  "enum": [
                    "read_uncommitted",
                    "read_committed"
                  ],
                  "type": "string"
                },
                "consumer_max_partition_fetch_bytes": {
                  "description": "Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.",
                  "maximum": 104857600,
                  "minimum": 1048576,
                  "type": "integer"
                },
                "consumer_max_poll_interval_ms": {
                  "description": "The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).",
                  "maximum": 2147483647,
                  "minimum": 1,
                  "type": "integer"
                },
                "consumer_max_poll_records": {
                  "description": "The maximum number of records returned in a single call to poll() (defaults to 500).",
                  "maximum": 10000,
                  "minimum": 1,
                  "type": "integer"
                },
                "offset_flush_interval_ms": {
                  "description": "The interval at which to try committing offsets for tasks (defaults to 60000).",
                  "maximum": 100000000,
                  "minimum": 1,
                  "type": "integer"
                },
                "offset_flush_timeout_ms": {
                  "description": "Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).",
                  "maximum": 2147483647,
                  "minimum": 1,
                  "type": "integer"
                },
                "producer_batch_size": {
                  "description": "This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will 'linger' for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).",
                  "maximum": 5242880,
                  "minimum": 0,
                  "type": "integer"
                },
                "producer_buffer_memory": {
                  "description": "The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).",
                  "maximum": 134217728,
                  "minimum": 5242880,
                  "type": "integer"
                },
                "producer_compression_type": {
                  "description": "Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.",
                  "enum": [
                    "gzip",
                    "snappy",
                    "lz4",
                    "zstd",
                    "none"
                  ],
                  "type": "string"
                },
                "producer_linger_ms": {
                  "description": "This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will 'linger' for the specified time waiting for more records to show up. Defaults to 0.",
                  "maximum": 5000,
                  "minimum": 0,
                  "type": "integer"
                },
                "producer_max_request_size": {
                  "description": "This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.",
                  "maximum": 67108864,
                  "minimum": 131072,
                  "type": "integer"
                },
                "scheduled_rebalance_max_delay_ms": {
                  "description": "The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.",
                  "maximum": 600000,
                  "minimum": 0,
                  "type": "integer"
                },
                "session_timeout_ms": {
                  "description": "The timeout in milliseconds used to detect failures when using Kafka\u2019s group management facilities (defaults to 10000).",
                  "maximum": 2147483647,
                  "minimum": 1,
                  "type": "integer"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "private_access": {
              "description": "Allow access to selected service ports from private networks",
              "properties": {
                "kafka_connect": {
                  "description": "Allow clients to connect to kafka_connect with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations",
                  "type": "boolean"
                },
                "prometheus": {
                  "description": "Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations",
                  "type": "boolean"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "privatelink_access": {
              "description": "Allow access to selected service components through Privatelink",
              "properties": {
                "jolokia": {
                  "description": "Enable jolokia",
                  "type": "boolean"
                },
                "kafka_connect": {
                  "description": "Enable kafka_connect",
                  "type": "boolean"
                },
                "prometheus": {
                  "description": "Enable prometheus",
                  "type": "boolean"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "public_access": {
              "description": "Allow access to selected service ports from the public Internet",
              "properties": {
                "kafka_connect": {
                  "description": "Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network",
                  "type": "boolean"
                },
                "prometheus": {
                  "description": "Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network",
                  "type": "boolean"
                }
              },
              "type": "object",
              "additionalProperties": false
            },
            "secret_providers": {
              "description": "Configure external secret providers in order to reference external secrets in connector configuration. Currently Hashicorp Vault (provider: vault, auth_method: token) and AWS Secrets Manager (provider: aws, auth_method: credentials) are supported. Secrets can be referenced in connector config with ${<provider_name>:<secret_path>:<key_name>}",
              "items": {
                "description": "SecretProvider",
                "properties": {
                  "aws": {
                    "description": "AWS config for Secret Provider",
                    "properties": {
                      "access_key": {
                        "description": "Access key used to authenticate with aws",
                        "maxLength": 128,
                        "type": "string"
                      },
                      "auth_method": {
                        "description": "Auth method of the vault secret provider",
                        "enum": [
                          "credentials"
                        ],
                        "type": "string"
                      },
                      "region": {
                        "description": "Region used to lookup secrets with AWS SecretManager",
                        "maxLength": 64,
                        "type": "string"
                      },
                      "secret_key": {
                        "description": "Secret key used to authenticate with aws",
                        "maxLength": 128,
                        "type": "string"
                      }
                    },
                    "required": [
                      "auth_method",
                      "region"
                    ],
                    "type": "object",
                    "additionalProperties": false
                  },
                  "name": {
                    "description": "Name of the secret provider. Used to reference secrets in connector config.",
                    "type": "string"
                  },
                  "vault": {
                    "description": "Vault Config for Secret Provider",
                    "properties": {
                      "address": {
                        "description": "Address of the Vault server",
                        "maxLength": 65536,
                        "minLength": 1,
                        "type": "string"
                      },
                      "auth_method": {
                        "description": "Auth method of the vault secret provider",
                        "enum": [
                          "token"
                        ],
                        "type": "string"
                      },
                      "engine_version": {
                        "description": "KV Secrets Engine version of the Vault server instance",
                        "enum": [
                          1,
                          2
                        ],
                        "type": "integer"
                      },
                      "token": {
                        "description": "Token used to authenticate with vault and auth method `token`.",
                        "maxLength": 256,
                        "type": "string"
                      }
                    },
                    "required": [
                      "address",
                      "auth_method"
                    ],
                    "type": "object",
                    "additionalProperties": false
                  }
                },
                "required": [
                  "name"
                ],
                "type": "object",
                "additionalProperties": false
              },
              "type": "array"
            },
            "service_log": {
              "description": "Store logs for the service so that they are available in the HTTP API and console.",
              "type": "boolean"
            },
            "static_ips": {
              "description": "Use static public IP addresses",
              "type": "boolean"
            }
          },
          "type": "object",
          "additionalProperties": false
        }
      },
      "required": [
        "plan",
        "project"
      ],
      "type": "object",
      "additionalProperties": false
    },
    "status": {
      "description": "ServiceStatus defines the observed state of service",
      "properties": {
        "conditions": {
          "description": "Conditions represent the latest available observations of a service state",
          "items": {
            "description": "Condition contains details for one aspect of the current state of this API Resource.\n---\nThis struct is intended for direct use as an array at the field path .status.conditions.  For example,\n\n\n\ttype FooStatus struct{\n\t    // Represents the observations of a foo's current state.\n\t    // Known .status.conditions.type are: \"Available\", \"Progressing\", and \"Degraded\"\n\t    // +patchMergeKey=type\n\t    // +patchStrategy=merge\n\t    // +listType=map\n\t    // +listMapKey=type\n\t    Conditions []metav1.Condition `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\" protobuf:\"bytes,1,rep,name=conditions\"`\n\n\n\t    // other fields\n\t}",
            "properties": {
              "lastTransitionTime": {
                "description": "lastTransitionTime is the last time the condition transitioned from one status to another.\nThis should be when the underlying condition changed.  If that is not known, then using the time when the API field changed is acceptable.",
                "format": "date-time",
                "type": "string"
              },
              "message": {
                "description": "message is a human readable message indicating details about the transition.\nThis may be an empty string.",
                "maxLength": 32768,
                "type": "string"
              },
              "observedGeneration": {
                "description": "observedGeneration represents the .metadata.generation that the condition was set based upon.\nFor instance, if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration is 9, the condition is out of date\nwith respect to the current state of the instance.",
                "format": "int64",
                "minimum": 0,
                "type": "integer"
              },
              "reason": {
                "description": "reason contains a programmatic identifier indicating the reason for the condition's last transition.\nProducers of specific condition types may define expected values and meanings for this field,\nand whether the values are considered a guaranteed API.\nThe value should be a CamelCase string.\nThis field may not be empty.",
                "maxLength": 1024,
                "minLength": 1,
                "pattern": "^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$",
                "type": "string"
              },
              "status": {
                "description": "status of the condition, one of True, False, Unknown.",
                "enum": [
                  "True",
                  "False",
                  "Unknown"
                ],
                "type": "string"
              },
              "type": {
                "description": "type of condition in CamelCase or in foo.example.com/CamelCase.\n---\nMany .condition.type values are consistent across resources like Available, but because arbitrary conditions can be\nuseful (see .node.status.conditions), the ability to deconflict is important.\nThe regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)",
                "maxLength": 316,
                "pattern": "^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$",
                "type": "string"
              }
            },
            "required": [
              "lastTransitionTime",
              "message",
              "reason",
              "status",
              "type"
            ],
            "type": "object",
            "additionalProperties": false
          },
          "type": "array"
        },
        "state": {
          "description": "Service state",
          "type": "string"
        }
      },
      "type": "object",
      "additionalProperties": false
    }
  },
  "type": "object"
}