services

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 26, 2026 License: Apache-2.0 Imports: 1 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var Cassandra types.Service = types.Service{
	Name:  "cassandra",
	Image: "docker.io/cassandra",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "cassandra-data",
			Dest: "/var/lib/cassandra",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 9042,
			HostPort:      9042,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Cluster Name",
			Key:     "CASSANDRA_CLUSTER_NAME",
			Value:   "tent-cluster",
			Mutable: true,
		},
	},
}

Cassandra service holds necessary data for creating and running the Cassandra container.

View Source 
var ClickHouse types.Service = types.Service{
	Name:  "clickhouse",
	Image: "docker.io/clickhouse/clickhouse-server",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "clickhouse-data",
			Dest: "/var/lib/clickhouse",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "HTTP Port",
			ContainerPort: 8123,
			HostPort:      8123,
		},
		{
			Text:          "Native Port",
			ContainerPort: 9000,
			HostPort:      9000,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Default Database",
			Key:     "CLICKHOUSE_DB",
			Value:   "default",
			Mutable: true,
		},
		{
			Text:    "Default Username",
			Key:     "CLICKHOUSE_USER",
			Value:   "default",
			Mutable: true,
		},
		{
			Text:    "Default Password",
			Key:     "CLICKHOUSE_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
	},
	InsecureEnv: []types.EnvVar{
		{
			Key:   "CLICKHOUSE_DB",
			Value: "default",
		},
		{
			Key:   "CLICKHOUSE_USER",
			Value: "default",
		},
	},
	InsecureInfo: "username: default, password: (empty)",
}

ClickHouse service holds necessary data for creating and running the ClickHouse container.

View Source 
var CouchDB types.Service = types.Service{
	Name:  "couchdb",
	Image: "docker.io/couchdb",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "couchdb-data",
			Dest: "/opt/couchdb/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 5984,
			HostPort:      5984,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Admin Username",
			Key:     "COUCHDB_USER",
			Value:   "admin",
			Mutable: true,
		},
		{
			Text:    "Admin Password",
			Key:     "COUCHDB_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
	},
}

CouchDB service holds necessary data for creating and running the CouchDB container.

View Source 
var DynamoDB types.Service = types.Service{
	Name:  "dynamodb",
	Image: "docker.io/amazon/dynamodb-local",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "dynamodb-data",
			Dest: "/dynamodb_local_db",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 8000,
			HostPort:      8000,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Discovery Mode",
			Key:     "discovery.type",
			Value:   "single-node",
			Mutable: false,
		},
	},
	Command: []string{"-jar", "DynamoDBLocal.jar", "--sharedDb", "-dbPath", "/dynamodb_local_db"},
}

DynamoDB service holds necessary data for creating and running the DynamoDB container.

View Source 
var ElasticSearch types.Service = types.Service{
	Name:  "elasticsearch",
	Image: "docker.io/elasticsearch",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "elasticsearch-data",
			Dest: "/usr/share/elasticsearch/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 9200,
			HostPort:      9200,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Discovery Mode",
			Key:     "discovery.type",
			Value:   "single-node",
			Mutable: false,
		},
	},
}

ElasticSearch service holds necessary data for creating and running the ElasticSearch container.

View Source 
var InfluxDB types.Service = types.Service{
	Name:  "influxdb",
	Image: "docker.io/influxdb",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "influxdb-data",
			Dest: "/var/lib/influxdb2",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 8086,
			HostPort:      8086,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Init Mode",
			Key:     "DOCKER_INFLUXDB_INIT_MODE",
			Value:   "setup",
			Mutable: false,
		},
		{
			Text:    "Admin Username",
			Key:     "DOCKER_INFLUXDB_INIT_USERNAME",
			Value:   "admin",
			Mutable: true,
		},
		{
			Text:    "Admin Password",
			Key:     "DOCKER_INFLUXDB_INIT_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
		{
			Text:    "Organization",
			Key:     "DOCKER_INFLUXDB_INIT_ORG",
			Value:   "tent",
			Mutable: true,
		},
		{
			Text:    "Default Bucket",
			Key:     "DOCKER_INFLUXDB_INIT_BUCKET",
			Value:   "default",
			Mutable: true,
		},
	},
}

InfluxDB service holds necessary data for creating and running the InfluxDB container.

View Source 
var MailHog types.Service = types.Service{
	Name:  "mailhog",
	Image: "docker.io/mailhog/mailhog",
	Tag:   "latest",
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 1025,
			HostPort:      1025,
		},
		{
			Text:          "Web UI Port",
			ContainerPort: 8025,
			HostPort:      8025,
		},
	},
}

MailHog service holds necessary data for creating and running the MailHog container.

View Source 
var Mailpit types.Service = types.Service{
	Name:  "mailpit",
	Image: "docker.io/axllent/mailpit",
	Tag:   "latest",
	PortMappings: []types.PortMapping{
		{
			Text:          "SMTP Port",
			ContainerPort: 1025,
			HostPort:      1025,
		},
		{
			Text:          "Web UI Port",
			ContainerPort: 8025,
			HostPort:      8025,
		},
	},
}

Mailpit service holds necessary data for creating and running the Mailpit container.

View Source 
var MariaDB types.Service = types.Service{
	Name:  "mariadb",
	Image: "docker.io/mariadb",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "mariadb-data",
			Dest: "/var/lib/mysql",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 3306,
			HostPort:      3306,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Server Root Password",
			Key:     "MYSQL_ROOT_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
	},
	InsecureEnv: []types.EnvVar{
		{Key: "MARIADB_ALLOW_EMPTY_ROOT_PASSWORD", Value: "yes"},
	},
	InsecureInfo: "username: root, password: (empty)",
}

MariaDB service holds necessary data for creating and running the MariaDB container.

View Source 
var MeiliSearch types.Service = types.Service{
	Name:  "meilisearch",
	Image: "docker.io/getmeili/meilisearch",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "meilisearch-data",
			Dest: "/data.ms",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 7700,
			HostPort:      7700,
		},
	},
}

MeiliSearch service holds necessary data for creating and running the MeiliSearch container.

View Source 
var Memcached types.Service = types.Service{
	Name:  "memcached",
	Image: "docker.io/memcached",
	Tag:   "latest",
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 11211,
			HostPort:      11211,
		},
	},
}

Memcached service holds necessary data for creating and running the Memcached container.

View Source 
var MicrosoftSQLServer types.Service = types.Service{
	Name:  "mssql",
	Image: "mcr.microsoft.com/mssql/server",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "mssql-data",
			Dest: "/var/opt/mssql",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 1433,
			HostPort:      1433,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Server Root Password",
			Key:     "SA_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
		{
			Text:    "Accept EULA",
			Key:     "ACCEPT_EULA",
			Value:   "Y",
			Mutable: false,
		},
	},
}

MicrosoftSQLServer service holds necessary data for creating and running the MicrosoftSQLServer container.

View Source 
var MinIO types.Service = types.Service{
	Name:  "minio",
	Image: "docker.io/minio/minio",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "minio-data",
			Dest: "/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "API Port",
			ContainerPort: 9000,
			HostPort:      9000,
		},
		{
			Text:          "Console Port",
			ContainerPort: 9001,
			HostPort:      9001,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Root Username",
			Key:     "MINIO_ROOT_USER",
			Value:   "minioadmin",
			Mutable: true,
		},
		{
			Text:    "Root Password",
			Key:     "MINIO_ROOT_PASSWORD",
			Value:   "minioadmin",
			Mutable: true,
		},
	},
	Command: []string{"server", "/data", "--console-address", ":9001"},
}

MinIO service holds necessary data for creating and running the MinIO container.

View Source 
var Mongo types.Service = types.Service{
	Name:  "mongo",
	Image: "docker.io/mongo",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "mongo-data",
			Dest: "/data/db",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 27017,
			HostPort:      27017,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Server Admin Username",
			Key:     "MONGO_INITDB_ROOT_USERNAME",
			Value:   "admin",
			Mutable: true,
		},
		{
			Text:    "Server Admin Password",
			Key:     "MONGO_INITDB_ROOT_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
	},
	InsecureEnv:  []types.EnvVar{},
	InsecureInfo: "authentication disabled, no credentials required",
	Command:      []string{"--serviceExecutor", "adaptive"},
}

Mongo service holds necessary data for creating and running the Mongo container.

View Source 
var MySQL types.Service = types.Service{
	Name:  "mysql",
	Image: "docker.io/mysql",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "mysql-data",
			Dest: "/var/lib/mysql",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 3306,
			HostPort:      3306,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Server Root Password",
			Key:     "MYSQL_ROOT_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
	},
	InsecureEnv: []types.EnvVar{
		{Key: "MYSQL_ALLOW_EMPTY_PASSWORD", Value: "yes"},
	},
	InsecureInfo: "username: root, password: (empty)",
}

MySQL service holds necessary data for creating and running the MySQL container.

View Source 
var Neo4j types.Service = types.Service{
	Name:  "neo4j",
	Image: "docker.io/neo4j",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "neo4j-data",
			Dest: "/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "HTTP Port",
			ContainerPort: 7474,
			HostPort:      7474,
		},
		{
			Text:          "Bolt Port",
			ContainerPort: 7687,
			HostPort:      7687,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Authentication (user/pass)",
			Key:     "NEO4J_AUTH",
			Value:   "neo4j/secret",
			Mutable: true,
		},
	},
	InsecureEnv: []types.EnvVar{
		{Key: "NEO4J_AUTH", Value: "none"},
	},
	InsecureInfo: "authentication disabled, no credentials required",
}

Neo4j service holds necessary data for creating and running the Neo4j container.

View Source 
var OpenSearch types.Service = types.Service{
	Name:  "opensearch",
	Image: "docker.io/opensearchproject/opensearch",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "opensearch-data",
			Dest: "/usr/share/opensearch/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "REST API Port",
			ContainerPort: 9200,
			HostPort:      9200,
		},
		{
			Text:          "Performance Analyzer Port",
			ContainerPort: 9600,
			HostPort:      9600,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Discovery Mode",
			Key:     "discovery.type",
			Value:   "single-node",
			Mutable: false,
		},
		{
			Text:    "Disable Security Plugin",
			Key:     "DISABLE_SECURITY_PLUGIN",
			Value:   "true",
			Mutable: false,
		},
	},
}

OpenSearch service holds necessary data for creating and running the OpenSearch container.

View Source 
var PostGIS types.Service = types.Service{
	Name:  "postgis",
	Image: "docker.io/postgis/postgis",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "postgis-data",
			Dest: "/var/lib/postgis/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 5432,
			HostPort:      5432,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Server Root Password",
			Key:     "POSTGRES_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
	},
	InsecureEnv: []types.EnvVar{
		{Key: "POSTGRES_HOST_AUTH_METHOD", Value: "trust"},
	},
	InsecureInfo: "username: postgres, password: (none, trust auth)",
}

PostGIS service holds necessary data for creating and running the PostGIS container.

View Source 
var Postgres types.Service = types.Service{
	Name:  "postgres",
	Image: "docker.io/postgres",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "postgres-data",
			Dest: "/var/lib/postgresql/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 5432,
			HostPort:      5432,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Server Root Password",
			Key:     "POSTGRES_PASSWORD",
			Value:   "secret",
			Mutable: true,
		},
	},
	InsecureEnv: []types.EnvVar{
		{Key: "POSTGRES_HOST_AUTH_METHOD", Value: "trust"},
	},
	InsecureInfo: "username: postgres, password: (none, trust auth)",
}

Postgres service holds necessary data for creating and running the Postgres container.

View Source 
var RabbitMQ types.Service = types.Service{
	Name:  "rabbitmq",
	Image: "docker.io/rabbitmq",
	Tag:   "management",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "rabbitmq-data",
			Dest: "/var/lib/rabbitmq",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 5672,
			HostPort:      5672,
		},
		{
			Text:          "Management UI Port",
			ContainerPort: 15672,
			HostPort:      15672,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Default Username",
			Key:     "RABBITMQ_DEFAULT_USER",
			Value:   "guest",
			Mutable: true,
		},
		{
			Text:    "Default Password",
			Key:     "RABBITMQ_DEFAULT_PASS",
			Value:   "guest",
			Mutable: true,
		},
	},
}

RabbitMQ service holds necessary data for creating and running the RabbitMQ container.

View Source 
var Redis types.Service = types.Service{
	Name:  "redis",
	Image: "docker.io/redis",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "redis-data",
			Dest: "/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 6379,
			HostPort:      6379,
		},
	},
}

Redis service holds necessary data for creating and running the Redis container.

View Source 
var SurrealDB types.Service = types.Service{
	Name:  "surrealdb",
	Image: "docker.io/surrealdb/surrealdb",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "surrealdb-data",
			Dest: "/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 8000,
			HostPort:      8000,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "Root Username",
			Key:     "SURREAL_USER",
			Value:   "root",
			Mutable: true,
		},
		{
			Text:    "Root Password",
			Key:     "SURREAL_PASS",
			Value:   "secret",
			Mutable: true,
		},
	},
	InsecureEnv:  []types.EnvVar{},
	InsecureInfo: "authentication disabled, no credentials required",
	Command:      []string{"start", "--log", "info", "file:/data/srdb.db"},
}

SurrealDB service holds necessary data for creating and running the SurrealDB container.

View Source 
var Typesense types.Service = types.Service{
	Name:  "typesense",
	Image: "docker.io/typesense/typesense",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "typesense-data",
			Dest: "/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 8108,
			HostPort:      8108,
		},
	},
	Env: []types.EnvVar{
		{
			Text:    "API Key",
			Key:     "TYPESENSE_API_KEY",
			Value:   "secret",
			Mutable: true,
		},
		{
			Text:    "Data Directory",
			Key:     "TYPESENSE_DATA_DIR",
			Value:   "/data",
			Mutable: false,
		},
	},
}

Typesense service holds necessary data for creating and running the Typesense container.

View Source 
var Valkey types.Service = types.Service{
	Name:  "valkey",
	Image: "docker.io/valkey/valkey",
	Tag:   "latest",
	Volumes: []types.VolumeMount{
		{
			Text: "Server Data Volume",
			Name: "valkey-data",
			Dest: "/data",
		},
	},
	PortMappings: []types.PortMapping{
		{
			Text:          "Server Port",
			ContainerPort: 6379,
			HostPort:      6379,
		},
	},
}

Valkey service holds necessary data for creating and running the Valkey container.

Functions

This section is empty.

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.