Struct KafkaProxy 

pub struct KafkaProxy {
    pub certificate: String,
    pub cpus: f64,
    pub enable_kafka_acl_groups: Option<bool>,
    pub instances: NonZeroU64,
    pub mem: i64,
    pub name: Option<String>,
    pub schema_store: Option<bool>,
    pub schema_store_cpus: Option<f64>,
    pub schema_store_mem: Option<i64>,
    pub secret_name_ca_chain: String,
    pub validations: Vec<Validations>,
    pub zone: KafkaProxyZone,
}

KafkaProxy

JSON schema

{
 "type": "object",
 "required": [
   "certificate",
   "cpus",
   "instances",
   "mem",
   "secretNameCaChain",
   "zone"
 ],
 "properties": {
   "certificate": {
     "description": "Secret name with the server certificate",
     "type": "string"
   },
   "cpus": {
     "description": "CPU quota for each Kafka Proxy (minimum 0.3 = 30% of 1 CPU)",
     "type": "number",
     "minimum": 0.3,
     "example": 0.3
   },
   "enableKafkaAclGroups": {
     "description": "Set to True to enable the ACL groups (Advanced feature: without the correct acl groups in place this will result in a non-functioning proxy instance)\n",
     "type": "boolean"
   },
   "instances": {
     "description": "Number of instances",
     "type": "integer",
     "minimum": 1.0,
     "example": 2
   },
   "mem": {
     "description": "Memory (MB) for each Kafka Proxy (minimum 1024 = 1 GB)",
     "type": "integer",
     "minimum": 1024.0,
     "example": 3072
   },
   "name": {
     "description": "Name of the new Kafka Proxy",
     "type": "string"
   },
   "schemaStore": {
     "description": "Set to True no enable Schema Store",
     "type": "boolean"
   },
   "schemaStoreCpus": {
     "description": "CPU quota for Schema Store (minimum 0.3 = 30% of 1 CPU)",
     "type": "number",
     "minimum": 0.1,
     "example": 0.1
   },
   "schemaStoreMem": {
     "description": "Memory (MB) for Schema Store (minimum 256MB)",
     "type": "integer",
     "minimum": 256.0,
     "example": 256
   },
   "secretNameCaChain": {
     "description": "Secret name containing the Ca Cert",
     "type": "string"
   },
   "validations": {
     "type": "array",
     "items": {
       "$ref": "#/components/schemas/Validations"
     }
   },
   "zone": {
     "description": "Available networks on this platform",
     "type": "string",
     "enum": [
       "private",
       "public"
     ]
   }
 },
 "example": {
   "certificate": "certificate",
   "cpus": 0.3,
   "enableKafkaAclGroups": true,
   "instances": 2,
   "mem": 3072,
   "name": "name",
   "schemaStore": true,
   "schemaStoreCpus": 0.1,
   "schemaStoreMem": 256,
   "secretNameCaChain": "secretNameCaChain",
   "validations": [
     {
       "commonName": "commonName",
       "country": "country",
       "locality": "locality",
       "organization": "organization",
       "organizationalUnit": "organizationalUnit",
       "province": "province",
       "subjectType": "subjectType"
     },
     {
       "commonName": "commonName",
       "country": "country",
       "locality": "locality",
       "organization": "organization",
       "organizationalUnit": "organizationalUnit",
       "province": "province",
       "subjectType": "subjectType"
     }
   ],
   "zone": "private"
 }
}

Fields

certificate: String

Secret name with the server certificate

cpus: f64

enable_kafka_acl_groups: Option<bool>

Set to True to enable the ACL groups (Advanced feature: without the correct acl groups in place this will result in a non-functioning proxy instance)

instances: NonZeroU64

Number of instances

mem: i64

Memory (MB) for each Kafka Proxy (minimum 1024 = 1 GB)

name: Option<String>

Name of the new Kafka Proxy

schema_store: Option<bool>

Set to True no enable Schema Store

schema_store_cpus: Option<f64>

schema_store_mem: Option<i64>

Memory (MB) for Schema Store (minimum 256MB)

secret_name_ca_chain: String

Secret name containing the Ca Cert

validations: Vec<Validations>

zone: KafkaProxyZone

Available networks on this platform

Implementations

impl KafkaProxy

pub fn builder() -> KafkaProxy

Trait Implementations

impl Clone for KafkaProxy

fn clone(&self) -> KafkaProxy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KafkaProxy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KafkaProxy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<KafkaProxy> for KafkaProxy

fn from(value: KafkaProxy) -> Self

Converts to this type from the input type.

impl PartialEq for KafkaProxy

fn eq(&self, other: &KafkaProxy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for KafkaProxy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<KafkaProxy> for KafkaProxy

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: KafkaProxy) -> Result<Self, ConversionError>

Performs the conversion.

impl StructuralPartialEq for KafkaProxy