Ben Vincent
d8751ac6c8
- add additional modules in Puppetfile
- update puppetlabs-lvm to 2.1.0
- add facts.d base path to hieradata
- add infra/storage and infra/storage/minio role data to hieradata
- add new facts for minio setup status
- add a static yaml minio-facts file to assist dynamic ruby facts
- updated hiera with additional directories (country/{role,region})
209 lines
8.2 KiB
Puppet
209 lines
8.2 KiB
Puppet
# profiles::minio::server
|
|
class profiles::minio::server (
|
|
String $minio_root_user,
|
|
String $minio_root_pass,
|
|
Array $minio_opts = [],
|
|
Boolean $minio_members_lookup = false,
|
|
String $minio_members_role = undef,
|
|
Integer $minio_members = undef,
|
|
Array $minio_servers = [],
|
|
String $minio_storage_class = 'EC:2',
|
|
String $version = 'RELEASE.2023-12-20T01-00-02Z',
|
|
String $checksum = '09fafaf399885b4912bafda6fa03fc4ccbc39ec45e17239677217317915d6aeb',
|
|
String $checksum_type = 'sha256',
|
|
String $owner = 'minio',
|
|
String $group = 'minio',
|
|
Stdlib::Fqdn $url_domain = $::facts['networking']['domain'],
|
|
Enum['http', 'https'] $url_scheme = 'http',
|
|
Enum['puppet', undef] $cert_type = 'puppet',
|
|
Array[String[0]] $blockdev = [],
|
|
Stdlib::Port $listen_port = 9000,
|
|
Stdlib::IP::Address $listen_addr = $::facts['networking']['ip'],
|
|
Stdlib::AbsolutePath $datadir = '/data/minio',
|
|
Stdlib::AbsolutePath $confdir = '/etc/minio',
|
|
Stdlib::AbsolutePath $homedir = '/var/lib/minio',
|
|
Stdlib::AbsolutePath $bindir = '/opt/minio',
|
|
) {
|
|
|
|
# create the region string
|
|
$minio_region = "${::facts['country']}-${::facts['region']}"
|
|
|
|
# count the block devices
|
|
$blockdev_count = count($blockdev)
|
|
|
|
# create minio static facts, which are used by pre-compile facts
|
|
file { "${lookup('facts_path')}/minio_facts.yaml":
|
|
ensure => file,
|
|
content => template('profiles/minio/minio_facts.yaml.erb'),
|
|
}
|
|
|
|
# create the user if its not yet initialised, if it is initialised, let the minio::server class manage
|
|
# manage the resource. This is done so that the user/group exist before attempting to create the data-
|
|
# directories.
|
|
if ! $::facts['minio_user_exists'] {
|
|
class {'minio::server::user':
|
|
manage_user => true,
|
|
manage_group => true,
|
|
manage_home => true,
|
|
owner => $owner,
|
|
group => $group,
|
|
home => $homedir,
|
|
}
|
|
}
|
|
|
|
# create the datadir
|
|
if ! $::facts['minio_datadirs_initialised'] {
|
|
|
|
# create the datadir root
|
|
exec { "mkdir_p_${datadir}":
|
|
command => "mkdir -p '${datadir}'",
|
|
unless => "test -d '${datadir}'",
|
|
path => '/bin:/usr/bin',
|
|
}
|
|
|
|
# create te datavol's if blockdev's are listed
|
|
$blockdev.each |Integer $index, String $device| {
|
|
$id = $index + 1
|
|
profiles::storage::datavol {"${::facts['networking']['fqdn']}_${device}":
|
|
fstype => 'xfs',
|
|
vg => "minio_vg${id}",
|
|
pv => $device,
|
|
lv => "store${id}",
|
|
owner => $owner,
|
|
group => $group,
|
|
mount => "${datadir}/store${id}",
|
|
require => Exec["mkdir_p_${datadir}"],
|
|
}
|
|
}
|
|
}
|
|
|
|
# copy puppet certs to /etc/pki/tls/puppet
|
|
include profiles::pki::puppetcerts
|
|
|
|
# create the cert configuration hash
|
|
if $cert_type == 'puppet' {
|
|
$cert_conf = {
|
|
'source_path' => '/etc/pki/tls/puppet',
|
|
'source_cert_name' => $::facts['networking']['fqdn'],
|
|
'source_key_name' => $::facts['networking']['fqdn'],
|
|
}
|
|
}
|
|
|
|
# if lookup is enabled, find all the hosts in the specified role and create the servers_array
|
|
if $minio_members_lookup {
|
|
|
|
# check that the role is also set
|
|
unless !($minio_members_role == undef) {
|
|
fail("minio_members_role must be provided for ${title} when minio_members_lookup is True")
|
|
}
|
|
|
|
# if it is, find hosts, sort them so they dont cause changes every run
|
|
#$servers_array = sort(query_nodes("enc_role='${minio_members_role}'", 'networking.fqdn'))
|
|
$servers_array = sort(query_nodes("enc_role='${minio_members_role}' and minio_region='${minio_region}'", 'networking.fqdn'))
|
|
|
|
# else use provided array from params
|
|
}else{
|
|
$servers_array = $minio_servers
|
|
}
|
|
|
|
# iterate through the servers_array and find the nodeid for each host
|
|
$servers_array.each |Integer $index, String $server| {
|
|
$id = $index + 1
|
|
if $::facts['networking']['fqdn'] == $server {
|
|
$nodeid = $id
|
|
if $::facts['minio_pool'] != undef {
|
|
|
|
# create a cname which is used to create a sequential group of names for distributed minio pool
|
|
profiles::dns::record { "${minio_region}-${::facts['minio_pool']}-${nodeid}.${::facts['networking']['domain']}_CNAME":
|
|
value => $::facts['networking']['hostname'],
|
|
type => 'CNAME',
|
|
record => "${minio_region}-${::facts['minio_pool']}-${nodeid}.${::facts['networking']['domain']}.",
|
|
zone => $::facts['networking']['domain'],
|
|
order => 10,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# wait until all expected servers in the pool have reported into puppet
|
|
if count($servers_array) == $::facts['minio_members'] and $::facts['minio_pool'] != undef {
|
|
|
|
# if datadirs and user have been initialised, prepare configuration.
|
|
if $::facts['minio_datadirs_initialised'] and $::facts['minio_user_exists'] {
|
|
|
|
# join the minio_opts
|
|
$options = join($minio_opts, ' ')
|
|
|
|
# create vars for $deployment_definition, others used below are params
|
|
$url_location = "${minio_region}-${::facts['minio_pool']}"
|
|
$url_servers = "1...${count($servers_array)}"
|
|
|
|
# create the deployment definition line
|
|
# >= 1 : https://au-somewhere-1-pool1-{1...5}.example.domain/var/minio/store{1...4}
|
|
# == 1 : https://au-somewhere-1-pool1-{1...5}.example.domain/var/minio/store1
|
|
# else : https://au-somewhere-1-pool1-{1...5}.example.domain/var/minio
|
|
if $blockdev_count >= 1 {
|
|
$deployment_definition = "${url_scheme}://${url_location}-{${url_servers}}.${url_domain}:${listen_port}${datadir}/store{1...${blockdev_count}}"
|
|
}elsif $blockdev_count == 1 {
|
|
$deployment_definition = "${url_scheme}://${url_location}-{${url_servers}}.${url_domain}:${listen_port}${datadir}/store1"
|
|
}else{
|
|
$deployment_definition = "${url_scheme}://${url_location}-{${url_servers}}.${url_domain}:${listen_port}${datadir}"
|
|
}
|
|
|
|
# create the configuration hash
|
|
$configuration = {
|
|
'MINIO_ROOT_USER' => $minio_root_user,
|
|
'MINIO_ROOT_PASSWORD' => $minio_root_pass.unwrap,
|
|
'MINIO_REGION_NAME' => $minio_region,
|
|
'MINIO_OPTS' => "\'${options}\'",
|
|
'MINIO_DEPLOYMENT_DEFINITION' => $deployment_definition,
|
|
'MINIO_STORAGE_CLASS_STANDARD' => $minio_storage_class,
|
|
}
|
|
}
|
|
}
|
|
|
|
# check all the expected DNS CNAME records do not exist
|
|
$all_dns_exist = $::facts['minio_pool_dns'].all |String $cname, Boolean $exists| { $exists }
|
|
|
|
# create the minio server if all dns records exist
|
|
if $all_dns_exist {
|
|
class { 'minio::server::install':
|
|
package_ensure => 'present',
|
|
owner => $owner,
|
|
group => $group,
|
|
base_url => 'https://dl.minio.io/server/minio/release',
|
|
version => $version,
|
|
checksum => $checksum,
|
|
checksum_type => $checksum_type,
|
|
configuration_directory => $confdir,
|
|
installation_directory => $bindir,
|
|
storage_root => $datadir,
|
|
listen_ip => $listen_addr,
|
|
listen_port => $listen_port,
|
|
manage_service => true,
|
|
service_template => 'profiles/minio/minio.service.erb',
|
|
service_provider => 'systemd',
|
|
cert_directory => "${confdir}/certs",
|
|
custom_configuration_file_path => '/etc/default/minio',
|
|
}
|
|
|
|
class { 'minio::server::config':
|
|
owner => $owner,
|
|
group => $group,
|
|
configuration_directory => $confdir,
|
|
installation_directory => $bindir,
|
|
storage_root => $datadir,
|
|
configuration => $configuration,
|
|
custom_configuration_file_path => '/etc/default/minio',
|
|
require => Class['Minio::Server::Install'],
|
|
}
|
|
|
|
class { 'minio::server::service':
|
|
manage_service => true,
|
|
service_provider => 'systemd',
|
|
service_ensure => 'running',
|
|
require => Class['Minio::Server::Config'],
|
|
}
|
|
}
|
|
}
|