def reset():
utils.print_bold('Trying to wipe the database')
command = [
'docker-compose',
'-f',
constants.FULL_COMPOSE_PATH,
'run',
'initializer',
'python3',
'/app/scripts/reset_db.py',
]
subprocess.run(
command,
cwd=constants.BASE_DIR,
stdout=subprocess.DEVNULL,
check=False,
)
utils.print_bold('Bringing down services')
command = [
'docker-compose',
'-f',
constants.FULL_COMPOSE_PATH,
'down',
'-v',
'--remove-orphans',
]
utils.run_command(command, cwd=constants.BASE_DIR)
utils.print_success('Done!')
def validate(full: bool):
if full:
utils.print_bold('Validating full configuration for local deploy')
utils.load_config()
else:
utils.print_bold('Validating basic configuration for local deploy')
utils.load_basic_config()
utils.print_success('Configuration is valid!')
def reset(ctx: click.Context):
utils.print_bold('Removing skaffold-created resources')
utils.run_command(['skaffold', 'delete', '-f', 'deploy/skaffold.yml'],
cwd=BASE_DIR)
utils.print_bold('Cleaning up')
ctx.invoke(clean)
utils.print_success('Done!')
def start(dev: bool, **_kwargs):
utils.print_bold('Deploying using skaffold')
cmd = ['skaffold', 'dev' if dev else 'run', '-f', 'deploy/skaffold.yml']
utils.run_command(cmd, cwd=BASE_DIR)
utils.print_success('Deployed successfully!')
utils.print_bold('Fetching the address for deployment')
service_resource = get_resource_description(resource='service',
name='nginx')
ip = service_resource['status']['loadBalancer']['ingress'][0]['ip']
utils.print_success(f'You can access ForcAD at http://{ip}')
def validate(full: bool, yandex: bool):
if full:
utils.print_bold('Validating full configuration for kubernetes')
config = utils.load_config()
if yandex:
check_admin_for_yandex(config.admin)
else:
utils.print_bold('Validating basic configuration for kubernetes')
config = utils.load_basic_config()
if yandex and config.admin:
check_admin_for_yandex(config.admin)
utils.print_success('Configuration is valid!')
def setup_rabbitmq(config: models.RabbitMQConfig):
management_url = f'http://{config.user}:{config.password}@{config.host}:15672/api/'
rabbitmq_config = [
"# THIS FILE IS MANAGED BY 'control.py'",
f'RABBITMQ_HOST={config.host}',
f'RABBITMQ_PORT={config.port}',
f'RABBITMQ_DEFAULT_USER={config.user}',
f'RABBITMQ_DEFAULT_PASS={config.password}',
f'RABBITMQ_DEFAULT_VHOST={config.vhost}',
f'BROKER_API_URL={management_url}',
]
utils.print_bold(f'Writing broker env to {constants.RABBITMQ_ENV_PATH}')
constants.RABBITMQ_ENV_PATH.write_text('\n'.join(rabbitmq_config))
def create(ctx: click.Context):
ctx.invoke(validate, full=False, yandex=True)
utils.backup_config()
basic_config = utils.load_basic_config()
config = utils.setup_auxiliary_structure(basic_config)
utils.dump_config(config)
utils.run_command(['terraform', 'init'], cwd=constants.TERRAFORM_DIR)
if not constants.TF_CREDENTIALS_PATH.exists():
zone_choices = click.Choice([f'ru-central1-{c}' for c in 'abc'])
data = {
"yandex_cloud_token":
click.prompt('Enter your YC OAuth token'),
"yandex_cloud_id":
click.prompt('Enter your YC cloud id'),
"yandex_folder_id":
click.prompt('Enter your YC folder id'),
"yandex_zone":
click.prompt(
'In which zone will you deploy ForcAD?',
type=zone_choices,
default=zone_choices.choices[0],
),
}
else:
data = json.loads(constants.TF_CREDENTIALS_PATH.read_text())
data['db_password'] = config.storages.db.password
data['db_user'] = config.storages.db.user
data['db_name'] = config.storages.db.dbname
constants.TF_CREDENTIALS_PATH.write_text(json.dumps(data))
utils.run_command(['terraform', 'plan'], cwd=constants.TERRAFORM_DIR)
click.confirm(
click.style('Does the plan above look ok?', bold=True),
abort=True,
)
utils.print_bold('Applying the plan with Terraform')
utils.run_command(
['terraform', 'apply', '-auto-approve'],
cwd=constants.TERRAFORM_DIR,
)
tf_out = get_terraform_outputs()
cluster_id = tf_out['cluster-id']['value']
folder_id = tf_out['folder-id']['value']
registry_id = tf_out['registry-id']['value']
postgres_fqdn = tf_out['postgres-fqdn']['value']
redis_fqdn = tf_out['redis-fqdn']['value']
utils.print_bold('Adding cluster config to kubectl')
cmd = [
'yc',
'managed-kubernetes',
'cluster',
'get-credentials',
'--id',
cluster_id,
'--folder-id',
folder_id,
'--context-name',
'yc-forcad',
'--external',
'--force',
]
utils.run_command(cmd)
utils.print_bold('New kubectl config:')
utils.run_command(['kubectl', 'config', 'view'])
utils.print_bold('Configuring local docker to authenticate in YC registry')
utils.run_command(['yc', 'container', 'registry', 'configure-docker'])
repo = f'cr.yandex/{registry_id}'
utils.print_bold(f'Configuring skaffold to use repo {repo} by default')
utils.run_command(['skaffold', 'config', 'set', 'default-repo', repo])
database = f'{postgres_fqdn}:6432'
redis = f'{redis_fqdn}:6379'
utils.print_bold(f'Postgres full address is {database}')
utils.print_bold(f'Redis full address is {redis}')
ctx.invoke(setup, database=database, redis=redis, rabbitmq=None)
