Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BadRequestException

type BadRequestException struct {
	Message *string

	InvalidParameter *string
}

    Returns information about an error.

    func (*BadRequestException) Error

    func (e *BadRequestException) Error() string

    func (*BadRequestException) ErrorCode

    func (e *BadRequestException) ErrorCode() string

    func (*BadRequestException) ErrorFault

    func (e *BadRequestException) ErrorFault() smithy.ErrorFault

    func (*BadRequestException) ErrorMessage

    func (e *BadRequestException) ErrorMessage() string

    type BrokerAZDistribution

    type BrokerAZDistribution string
    const (
    	BrokerAZDistributionDefault BrokerAZDistribution = "DEFAULT"
    )

      Enum values for BrokerAZDistribution

      func (BrokerAZDistribution) Values

        Values returns all known values for BrokerAZDistribution. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

        type BrokerEBSVolumeInfo

        type BrokerEBSVolumeInfo struct {
        
        	// The ID of the broker to update.
        	//
        	// This member is required.
        	KafkaBrokerNodeId *string
        
        	// Size of the EBS volume to update.
        	//
        	// This member is required.
        	VolumeSizeGB int32
        }

          Specifies the EBS volume upgrade information. The broker identifier must be set to the keyword ALL. This means the changes apply to all the brokers in the cluster.

          type BrokerLogs

          type BrokerLogs struct {
          	CloudWatchLogs *CloudWatchLogs
          
          	Firehose *Firehose
          
          	S3 *S3
          }

          type BrokerNodeGroupInfo

          type BrokerNodeGroupInfo struct {
          
          	// The list of subnets to connect to in the client virtual private cloud (VPC). AWS
          	// creates elastic network interfaces inside these subnets. Client applications use
          	// elastic network interfaces to produce and consume data. Client subnets can't be
          	// in Availability Zone us-east-1e.
          	//
          	// This member is required.
          	ClientSubnets []string
          
          	// The type of Amazon EC2 instances to use for Kafka brokers. The following
          	// instance types are allowed: kafka.m5.large, kafka.m5.xlarge, kafka.m5.2xlarge,
          	// kafka.m5.4xlarge, kafka.m5.12xlarge, and kafka.m5.24xlarge.
          	//
          	// This member is required.
          	InstanceType *string
          
          	// The distribution of broker nodes across Availability Zones. This is an optional
          	// parameter. If you don't specify it, Amazon MSK gives it the value DEFAULT. You
          	// can also explicitly set this parameter to the value DEFAULT. No other values are
          	// currently allowed. Amazon MSK distributes the broker nodes evenly across the
          	// Availability Zones that correspond to the subnets you provide when you create
          	// the cluster.
          	BrokerAZDistribution BrokerAZDistribution
          
          	// The AWS security groups to associate with the elastic network interfaces in
          	// order to specify who can connect to and communicate with the Amazon MSK cluster.
          	// If you don't specify a security group, Amazon MSK uses the default security
          	// group associated with the VPC.
          	SecurityGroups []string
          
          	// Contains information about storage volumes attached to MSK broker nodes.
          	StorageInfo *StorageInfo
          }

            Describes the setup to be used for Kafka broker nodes in the cluster.

            type BrokerNodeInfo

            type BrokerNodeInfo struct {
            
            	// The attached elastic network interface of the broker.
            	AttachedENIId *string
            
            	// The ID of the broker.
            	BrokerId float64
            
            	// The client subnet to which this broker node belongs.
            	ClientSubnet *string
            
            	// The virtual private cloud (VPC) of the client.
            	ClientVpcIpAddress *string
            
            	// Information about the version of software currently deployed on the Kafka
            	// brokers in the cluster.
            	CurrentBrokerSoftwareInfo *BrokerSoftwareInfo
            
            	// Endpoints for accessing the broker.
            	Endpoints []string
            }

              BrokerNodeInfo

              type BrokerSoftwareInfo

              type BrokerSoftwareInfo struct {
              
              	// The Amazon Resource Name (ARN) of the configuration used for the cluster. This
              	// field isn't visible in this preview release.
              	ConfigurationArn *string
              
              	// The revision of the configuration to use. This field isn't visible in this
              	// preview release.
              	ConfigurationRevision int64
              
              	// The version of Apache Kafka.
              	KafkaVersion *string
              }

                Information about the current software installed on the cluster.

                type ClientAuthentication

                type ClientAuthentication struct {
                
                	// Details for ClientAuthentication using SASL.
                	Sasl *Sasl
                
                	// Details for ClientAuthentication using TLS.
                	Tls *Tls
                }

                  Includes all client authentication information.

                  type ClientBroker

                  type ClientBroker string
                  const (
                  	ClientBrokerTls          ClientBroker = "TLS"
                  	ClientBrokerTlsPlaintext ClientBroker = "TLS_PLAINTEXT"
                  	ClientBrokerPlaintext    ClientBroker = "PLAINTEXT"
                  )

                    Enum values for ClientBroker

                    func (ClientBroker) Values

                    func (ClientBroker) Values() []ClientBroker

                      Values returns all known values for ClientBroker. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                      type CloudWatchLogs

                      type CloudWatchLogs struct {
                      
                      	// This member is required.
                      	Enabled bool
                      
                      	LogGroup *string
                      }

                      type ClusterInfo

                      type ClusterInfo struct {
                      
                      	// Arn of active cluster operation.
                      	ActiveOperationArn *string
                      
                      	// Information about the broker nodes.
                      	BrokerNodeGroupInfo *BrokerNodeGroupInfo
                      
                      	// Includes all client authentication information.
                      	ClientAuthentication *ClientAuthentication
                      
                      	// The Amazon Resource Name (ARN) that uniquely identifies the cluster.
                      	ClusterArn *string
                      
                      	// The name of the cluster.
                      	ClusterName *string
                      
                      	// The time when the cluster was created.
                      	CreationTime *time.Time
                      
                      	// Information about the version of software currently deployed on the Kafka
                      	// brokers in the cluster.
                      	CurrentBrokerSoftwareInfo *BrokerSoftwareInfo
                      
                      	// The current version of the MSK cluster.
                      	CurrentVersion *string
                      
                      	// Includes all encryption-related information.
                      	EncryptionInfo *EncryptionInfo
                      
                      	// Specifies which metrics are gathered for the MSK cluster. This property has the
                      	// following possible values: DEFAULT, PER_BROKER, PER_TOPIC_PER_BROKER, and
                      	// PER_TOPIC_PER_PARTITION. For a list of the metrics associated with each of these
                      	// levels of monitoring, see Monitoring
                      	// (https://docs.aws.amazon.com/msk/latest/developerguide/monitoring.html).
                      	EnhancedMonitoring EnhancedMonitoring
                      
                      	LoggingInfo *LoggingInfo
                      
                      	// The number of broker nodes in the cluster.
                      	NumberOfBrokerNodes int32
                      
                      	// Settings for open monitoring using Prometheus.
                      	OpenMonitoring *OpenMonitoring
                      
                      	// The state of the cluster. The possible states are ACTIVE, CREATING, DELETING,
                      	// FAILED, HEALING, MAINTENANCE, REBOOTING_BROKER, and UPDATING.
                      	State ClusterState
                      
                      	StateInfo *StateInfo
                      
                      	// Tags attached to the cluster.
                      	Tags map[string]string
                      
                      	// The connection string to use to connect to the Apache ZooKeeper cluster.
                      	ZookeeperConnectString *string
                      
                      	// The connection string to use to connect to zookeeper cluster on Tls port.
                      	ZookeeperConnectStringTls *string
                      }

                        Returns information about a cluster.

                        type ClusterOperationInfo

                        type ClusterOperationInfo struct {
                        
                        	// The ID of the API request that triggered this operation.
                        	ClientRequestId *string
                        
                        	// ARN of the cluster.
                        	ClusterArn *string
                        
                        	// The time that the operation was created.
                        	CreationTime *time.Time
                        
                        	// The time at which the operation finished.
                        	EndTime *time.Time
                        
                        	// Describes the error if the operation fails.
                        	ErrorInfo *ErrorInfo
                        
                        	// ARN of the cluster operation.
                        	OperationArn *string
                        
                        	// State of the cluster operation.
                        	OperationState *string
                        
                        	// Steps completed during the operation.
                        	OperationSteps []ClusterOperationStep
                        
                        	// Type of the cluster operation.
                        	OperationType *string
                        
                        	// Information about cluster attributes before a cluster is updated.
                        	SourceClusterInfo *MutableClusterInfo
                        
                        	// Information about cluster attributes after a cluster is updated.
                        	TargetClusterInfo *MutableClusterInfo
                        }

                          Returns information about a cluster operation.

                          type ClusterOperationStep

                          type ClusterOperationStep struct {
                          
                          	// Information about the step and its status.
                          	StepInfo *ClusterOperationStepInfo
                          
                          	// The name of the step.
                          	StepName *string
                          }

                            Step taken during a cluster operation.

                            type ClusterOperationStepInfo

                            type ClusterOperationStepInfo struct {
                            
                            	// The steps current status.
                            	StepStatus *string
                            }

                              State information about the operation step.

                              type ClusterState

                              type ClusterState string
                              const (
                              	ClusterStateActive          ClusterState = "ACTIVE"
                              	ClusterStateCreating        ClusterState = "CREATING"
                              	ClusterStateDeleting        ClusterState = "DELETING"
                              	ClusterStateFailed          ClusterState = "FAILED"
                              	ClusterStateHealing         ClusterState = "HEALING"
                              	ClusterStateMaintenance     ClusterState = "MAINTENANCE"
                              	ClusterStateRebootingBroker ClusterState = "REBOOTING_BROKER"
                              	ClusterStateUpdating        ClusterState = "UPDATING"
                              )

                                Enum values for ClusterState

                                func (ClusterState) Values

                                func (ClusterState) Values() []ClusterState

                                  Values returns all known values for ClusterState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                  type CompatibleKafkaVersion

                                  type CompatibleKafkaVersion struct {
                                  
                                  	// A Kafka version.
                                  	SourceVersion *string
                                  
                                  	// A list of Kafka versions.
                                  	TargetVersions []string
                                  }

                                    Contains source Kafka versions and compatible target Kafka versions.

                                    type Configuration

                                    type Configuration struct {
                                    
                                    	// The Amazon Resource Name (ARN) of the configuration.
                                    	//
                                    	// This member is required.
                                    	Arn *string
                                    
                                    	// The time when the configuration was created.
                                    	//
                                    	// This member is required.
                                    	CreationTime *time.Time
                                    
                                    	// The description of the configuration.
                                    	//
                                    	// This member is required.
                                    	Description *string
                                    
                                    	// An array of the versions of Apache Kafka with which you can use this MSK
                                    	// configuration. You can use this configuration for an MSK cluster only if the
                                    	// Apache Kafka version specified for the cluster appears in this array.
                                    	//
                                    	// This member is required.
                                    	KafkaVersions []string
                                    
                                    	// Latest revision of the configuration.
                                    	//
                                    	// This member is required.
                                    	LatestRevision *ConfigurationRevision
                                    
                                    	// The name of the configuration.
                                    	//
                                    	// This member is required.
                                    	Name *string
                                    
                                    	// The state of the configuration. The possible states are ACTIVE, DELETING, and
                                    	// DELETE_FAILED.
                                    	//
                                    	// This member is required.
                                    	State ConfigurationState
                                    }

                                      Represents an MSK Configuration.

                                      type ConfigurationInfo

                                      type ConfigurationInfo struct {
                                      
                                      	// ARN of the configuration to use.
                                      	//
                                      	// This member is required.
                                      	Arn *string
                                      
                                      	// The revision of the configuration to use.
                                      	//
                                      	// This member is required.
                                      	Revision int64
                                      }

                                        Specifies the configuration to use for the brokers.

                                        type ConfigurationRevision

                                        type ConfigurationRevision struct {
                                        
                                        	// The time when the configuration revision was created.
                                        	//
                                        	// This member is required.
                                        	CreationTime *time.Time
                                        
                                        	// The revision number.
                                        	//
                                        	// This member is required.
                                        	Revision int64
                                        
                                        	// The description of the configuration revision.
                                        	Description *string
                                        }

                                          Describes a configuration revision.

                                          type ConfigurationState

                                          type ConfigurationState string
                                          const (
                                          	ConfigurationStateActive       ConfigurationState = "ACTIVE"
                                          	ConfigurationStateDeleting     ConfigurationState = "DELETING"
                                          	ConfigurationStateDeleteFailed ConfigurationState = "DELETE_FAILED"
                                          )

                                            Enum values for ConfigurationState

                                            func (ConfigurationState) Values

                                              Values returns all known values for ConfigurationState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                              type ConflictException

                                              type ConflictException struct {
                                              	Message *string
                                              
                                              	InvalidParameter *string
                                              }

                                                Returns information about an error.

                                                func (*ConflictException) Error

                                                func (e *ConflictException) Error() string

                                                func (*ConflictException) ErrorCode

                                                func (e *ConflictException) ErrorCode() string

                                                func (*ConflictException) ErrorFault

                                                func (e *ConflictException) ErrorFault() smithy.ErrorFault

                                                func (*ConflictException) ErrorMessage

                                                func (e *ConflictException) ErrorMessage() string

                                                type EBSStorageInfo

                                                type EBSStorageInfo struct {
                                                
                                                	// The size in GiB of the EBS volume for the data drive on each broker node.
                                                	VolumeSize int32
                                                }

                                                  Contains information about the EBS storage volumes attached to Kafka broker nodes.

                                                  type EncryptionAtRest

                                                  type EncryptionAtRest struct {
                                                  
                                                  	// The ARN of the AWS KMS key for encrypting data at rest. If you don't specify a
                                                  	// KMS key, MSK creates one for you and uses it.
                                                  	//
                                                  	// This member is required.
                                                  	DataVolumeKMSKeyId *string
                                                  }

                                                    The data-volume encryption details.

                                                    type EncryptionInTransit

                                                    type EncryptionInTransit struct {
                                                    
                                                    	// Indicates the encryption setting for data in transit between clients and
                                                    	// brokers. The following are the possible values. TLS means that client-broker
                                                    	// communication is enabled with TLS only. TLS_PLAINTEXT means that client-broker
                                                    	// communication is enabled for both TLS-encrypted, as well as plaintext data.
                                                    	// PLAINTEXT means that client-broker communication is enabled in plaintext only.
                                                    	// The default value is TLS_PLAINTEXT.
                                                    	ClientBroker ClientBroker
                                                    
                                                    	// When set to true, it indicates that data communication among the broker nodes of
                                                    	// the cluster is encrypted. When set to false, the communication happens in
                                                    	// plaintext. The default value is true.
                                                    	InCluster bool
                                                    }

                                                      The settings for encrypting data in transit.

                                                      type EncryptionInfo

                                                      type EncryptionInfo struct {
                                                      
                                                      	// The data-volume encryption details.
                                                      	EncryptionAtRest *EncryptionAtRest
                                                      
                                                      	// The details for encryption in transit.
                                                      	EncryptionInTransit *EncryptionInTransit
                                                      }

                                                        Includes encryption-related information, such as the AWS KMS key used for encrypting data at rest and whether you want MSK to encrypt your data in transit.

                                                        type EnhancedMonitoring

                                                        type EnhancedMonitoring string
                                                        const (
                                                        	EnhancedMonitoringDefault              EnhancedMonitoring = "DEFAULT"
                                                        	EnhancedMonitoringPerBroker            EnhancedMonitoring = "PER_BROKER"
                                                        	EnhancedMonitoringPerTopicPerBroker    EnhancedMonitoring = "PER_TOPIC_PER_BROKER"
                                                        	EnhancedMonitoringPerTopicPerPartition EnhancedMonitoring = "PER_TOPIC_PER_PARTITION"
                                                        )

                                                          Enum values for EnhancedMonitoring

                                                          func (EnhancedMonitoring) Values

                                                            Values returns all known values for EnhancedMonitoring. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                            type ErrorInfo

                                                            type ErrorInfo struct {
                                                            
                                                            	// A number describing the error programmatically.
                                                            	ErrorCode *string
                                                            
                                                            	// An optional field to provide more details about the error.
                                                            	ErrorString *string
                                                            }

                                                              Returns information about an error state of the cluster.

                                                              type Firehose

                                                              type Firehose struct {
                                                              
                                                              	// This member is required.
                                                              	Enabled bool
                                                              
                                                              	DeliveryStream *string
                                                              }

                                                              type ForbiddenException

                                                              type ForbiddenException struct {
                                                              	Message *string
                                                              
                                                              	InvalidParameter *string
                                                              }

                                                                Returns information about an error.

                                                                func (*ForbiddenException) Error

                                                                func (e *ForbiddenException) Error() string

                                                                func (*ForbiddenException) ErrorCode

                                                                func (e *ForbiddenException) ErrorCode() string

                                                                func (*ForbiddenException) ErrorFault

                                                                func (e *ForbiddenException) ErrorFault() smithy.ErrorFault

                                                                func (*ForbiddenException) ErrorMessage

                                                                func (e *ForbiddenException) ErrorMessage() string

                                                                type InternalServerErrorException

                                                                type InternalServerErrorException struct {
                                                                	Message *string
                                                                
                                                                	InvalidParameter *string
                                                                }

                                                                  Returns information about an error.

                                                                  func (*InternalServerErrorException) Error

                                                                  func (*InternalServerErrorException) ErrorCode

                                                                  func (e *InternalServerErrorException) ErrorCode() string

                                                                  func (*InternalServerErrorException) ErrorFault

                                                                  func (*InternalServerErrorException) ErrorMessage

                                                                  func (e *InternalServerErrorException) ErrorMessage() string

                                                                  type JmxExporter

                                                                  type JmxExporter struct {
                                                                  
                                                                  	// Indicates whether you want to enable or disable the JMX Exporter.
                                                                  	//
                                                                  	// This member is required.
                                                                  	EnabledInBroker bool
                                                                  }

                                                                    Indicates whether you want to enable or disable the JMX Exporter.

                                                                    type JmxExporterInfo

                                                                    type JmxExporterInfo struct {
                                                                    
                                                                    	// Indicates whether you want to enable or disable the JMX Exporter.
                                                                    	//
                                                                    	// This member is required.
                                                                    	EnabledInBroker bool
                                                                    }

                                                                      Indicates whether you want to enable or disable the JMX Exporter.

                                                                      type KafkaVersion

                                                                      type KafkaVersion struct {
                                                                      	Status KafkaVersionStatus
                                                                      
                                                                      	Version *string
                                                                      }

                                                                      type KafkaVersionStatus

                                                                      type KafkaVersionStatus string
                                                                      const (
                                                                      	KafkaVersionStatusActive     KafkaVersionStatus = "ACTIVE"
                                                                      	KafkaVersionStatusDeprecated KafkaVersionStatus = "DEPRECATED"
                                                                      )

                                                                        Enum values for KafkaVersionStatus

                                                                        func (KafkaVersionStatus) Values

                                                                          Values returns all known values for KafkaVersionStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                          type LoggingInfo

                                                                          type LoggingInfo struct {
                                                                          
                                                                          	// This member is required.
                                                                          	BrokerLogs *BrokerLogs
                                                                          }

                                                                          type MutableClusterInfo

                                                                          type MutableClusterInfo struct {
                                                                          
                                                                          	// Specifies the size of the EBS volume and the ID of the associated broker.
                                                                          	BrokerEBSVolumeInfo []BrokerEBSVolumeInfo
                                                                          
                                                                          	// Information about the changes in the configuration of the brokers.
                                                                          	ConfigurationInfo *ConfigurationInfo
                                                                          
                                                                          	// Specifies which Apache Kafka metrics Amazon MSK gathers and sends to Amazon
                                                                          	// CloudWatch for this cluster.
                                                                          	EnhancedMonitoring EnhancedMonitoring
                                                                          
                                                                          	// The Kafka version.
                                                                          	KafkaVersion *string
                                                                          
                                                                          	LoggingInfo *LoggingInfo
                                                                          
                                                                          	// The number of broker nodes in the cluster.
                                                                          	NumberOfBrokerNodes int32
                                                                          
                                                                          	// The settings for open monitoring.
                                                                          	OpenMonitoring *OpenMonitoring
                                                                          }

                                                                            Information about cluster attributes that can be updated via update APIs.

                                                                            type NodeExporter

                                                                            type NodeExporter struct {
                                                                            
                                                                            	// Indicates whether you want to enable or disable the Node Exporter.
                                                                            	//
                                                                            	// This member is required.
                                                                            	EnabledInBroker bool
                                                                            }

                                                                              Indicates whether you want to enable or disable the Node Exporter.

                                                                              type NodeExporterInfo

                                                                              type NodeExporterInfo struct {
                                                                              
                                                                              	// Indicates whether you want to enable or disable the Node Exporter.
                                                                              	//
                                                                              	// This member is required.
                                                                              	EnabledInBroker bool
                                                                              }

                                                                                Indicates whether you want to enable or disable the Node Exporter.

                                                                                type NodeInfo

                                                                                type NodeInfo struct {
                                                                                
                                                                                	// The start time.
                                                                                	AddedToClusterTime *string
                                                                                
                                                                                	// The broker node info.
                                                                                	BrokerNodeInfo *BrokerNodeInfo
                                                                                
                                                                                	// The instance type.
                                                                                	InstanceType *string
                                                                                
                                                                                	// The Amazon Resource Name (ARN) of the node.
                                                                                	NodeARN *string
                                                                                
                                                                                	// The node type.
                                                                                	NodeType NodeType
                                                                                
                                                                                	// The ZookeeperNodeInfo.
                                                                                	ZookeeperNodeInfo *ZookeeperNodeInfo
                                                                                }

                                                                                  The node information object.

                                                                                  type NodeType

                                                                                  type NodeType string
                                                                                  const (
                                                                                  	NodeTypeBroker NodeType = "BROKER"
                                                                                  )

                                                                                    Enum values for NodeType

                                                                                    func (NodeType) Values

                                                                                    func (NodeType) Values() []NodeType

                                                                                      Values returns all known values for NodeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                      type NotFoundException

                                                                                      type NotFoundException struct {
                                                                                      	Message *string
                                                                                      
                                                                                      	InvalidParameter *string
                                                                                      }

                                                                                        Returns information about an error.

                                                                                        func (*NotFoundException) Error

                                                                                        func (e *NotFoundException) Error() string

                                                                                        func (*NotFoundException) ErrorCode

                                                                                        func (e *NotFoundException) ErrorCode() string

                                                                                        func (*NotFoundException) ErrorFault

                                                                                        func (e *NotFoundException) ErrorFault() smithy.ErrorFault

                                                                                        func (*NotFoundException) ErrorMessage

                                                                                        func (e *NotFoundException) ErrorMessage() string

                                                                                        type OpenMonitoring

                                                                                        type OpenMonitoring struct {
                                                                                        
                                                                                        	// Prometheus settings.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	Prometheus *Prometheus
                                                                                        }

                                                                                          JMX and Node monitoring for the MSK cluster.

                                                                                          type OpenMonitoringInfo

                                                                                          type OpenMonitoringInfo struct {
                                                                                          
                                                                                          	// Prometheus settings.
                                                                                          	//
                                                                                          	// This member is required.
                                                                                          	Prometheus *PrometheusInfo
                                                                                          }

                                                                                            JMX and Node monitoring for the MSK cluster.

                                                                                            type Prometheus

                                                                                            type Prometheus struct {
                                                                                            
                                                                                            	// Indicates whether you want to enable or disable the JMX Exporter.
                                                                                            	JmxExporter *JmxExporter
                                                                                            
                                                                                            	// Indicates whether you want to enable or disable the Node Exporter.
                                                                                            	NodeExporter *NodeExporter
                                                                                            }

                                                                                              Prometheus settings.

                                                                                              type PrometheusInfo

                                                                                              type PrometheusInfo struct {
                                                                                              
                                                                                              	// Indicates whether you want to enable or disable the JMX Exporter.
                                                                                              	JmxExporter *JmxExporterInfo
                                                                                              
                                                                                              	// Indicates whether you want to enable or disable the Node Exporter.
                                                                                              	NodeExporter *NodeExporterInfo
                                                                                              }

                                                                                                Prometheus settings.

                                                                                                type S3

                                                                                                type S3 struct {
                                                                                                
                                                                                                	// This member is required.
                                                                                                	Enabled bool
                                                                                                
                                                                                                	Bucket *string
                                                                                                
                                                                                                	Prefix *string
                                                                                                }

                                                                                                type Sasl

                                                                                                type Sasl struct {
                                                                                                
                                                                                                	// Details for SASL/SCRAM client authentication.
                                                                                                	Scram *Scram
                                                                                                }

                                                                                                  Details for client authentication using SASL.

                                                                                                  type Scram

                                                                                                  type Scram struct {
                                                                                                  
                                                                                                  	// SASL/SCRAM authentication is enabled or not.
                                                                                                  	Enabled bool
                                                                                                  }

                                                                                                    Details for SASL/SCRAM client authentication.

                                                                                                    type ServiceUnavailableException

                                                                                                    type ServiceUnavailableException struct {
                                                                                                    	Message *string
                                                                                                    
                                                                                                    	InvalidParameter *string
                                                                                                    }

                                                                                                      Returns information about an error.

                                                                                                      func (*ServiceUnavailableException) Error

                                                                                                      func (*ServiceUnavailableException) ErrorCode

                                                                                                      func (e *ServiceUnavailableException) ErrorCode() string

                                                                                                      func (*ServiceUnavailableException) ErrorFault

                                                                                                      func (*ServiceUnavailableException) ErrorMessage

                                                                                                      func (e *ServiceUnavailableException) ErrorMessage() string

                                                                                                      type StateInfo

                                                                                                      type StateInfo struct {
                                                                                                      	Code *string
                                                                                                      
                                                                                                      	Message *string
                                                                                                      }

                                                                                                      type StorageInfo

                                                                                                      type StorageInfo struct {
                                                                                                      
                                                                                                      	// EBS volume information.
                                                                                                      	EbsStorageInfo *EBSStorageInfo
                                                                                                      }

                                                                                                        Contains information about storage volumes attached to MSK broker nodes.

                                                                                                        type Tls

                                                                                                        type Tls struct {
                                                                                                        
                                                                                                        	// List of ACM Certificate Authority ARNs.
                                                                                                        	CertificateAuthorityArnList []string
                                                                                                        }

                                                                                                          Details for client authentication using TLS.

                                                                                                          type TooManyRequestsException

                                                                                                          type TooManyRequestsException struct {
                                                                                                          	Message *string
                                                                                                          
                                                                                                          	InvalidParameter *string
                                                                                                          }

                                                                                                            Returns information about an error.

                                                                                                            func (*TooManyRequestsException) Error

                                                                                                            func (e *TooManyRequestsException) Error() string

                                                                                                            func (*TooManyRequestsException) ErrorCode

                                                                                                            func (e *TooManyRequestsException) ErrorCode() string

                                                                                                            func (*TooManyRequestsException) ErrorFault

                                                                                                            func (e *TooManyRequestsException) ErrorFault() smithy.ErrorFault

                                                                                                            func (*TooManyRequestsException) ErrorMessage

                                                                                                            func (e *TooManyRequestsException) ErrorMessage() string

                                                                                                            type UnauthorizedException

                                                                                                            type UnauthorizedException struct {
                                                                                                            	Message *string
                                                                                                            
                                                                                                            	InvalidParameter *string
                                                                                                            }

                                                                                                              Returns information about an error.

                                                                                                              func (*UnauthorizedException) Error

                                                                                                              func (e *UnauthorizedException) Error() string

                                                                                                              func (*UnauthorizedException) ErrorCode

                                                                                                              func (e *UnauthorizedException) ErrorCode() string

                                                                                                              func (*UnauthorizedException) ErrorFault

                                                                                                              func (e *UnauthorizedException) ErrorFault() smithy.ErrorFault

                                                                                                              func (*UnauthorizedException) ErrorMessage

                                                                                                              func (e *UnauthorizedException) ErrorMessage() string

                                                                                                              type UnprocessedScramSecret

                                                                                                              type UnprocessedScramSecret struct {
                                                                                                              
                                                                                                              	// Error code for associate/disassociate failure.
                                                                                                              	ErrorCode *string
                                                                                                              
                                                                                                              	// Error message for associate/disassociate failure.
                                                                                                              	ErrorMessage *string
                                                                                                              
                                                                                                              	// AWS Secrets Manager secret ARN.
                                                                                                              	SecretArn *string
                                                                                                              }

                                                                                                                Error info for scram secret associate/disassociate failure.

                                                                                                                type ZookeeperNodeInfo

                                                                                                                type ZookeeperNodeInfo struct {
                                                                                                                
                                                                                                                	// The attached elastic network interface of the broker.
                                                                                                                	AttachedENIId *string
                                                                                                                
                                                                                                                	// The virtual private cloud (VPC) IP address of the client.
                                                                                                                	ClientVpcIpAddress *string
                                                                                                                
                                                                                                                	// Endpoints for accessing the ZooKeeper.
                                                                                                                	Endpoints []string
                                                                                                                
                                                                                                                	// The role-specific ID for Zookeeper.
                                                                                                                	ZookeeperId float64
                                                                                                                
                                                                                                                	// The version of Zookeeper.
                                                                                                                	ZookeeperVersion *string
                                                                                                                }

                                                                                                                  Zookeeper node information.