def destroy(ctx, verbose):
"""
Uses Terraform to destroy Numerai Compute cluster in AWS.
This will delete everything, including:
- lambda url
- docker container and associated task
- all logs
This command is idempotent and safe to run multiple times.
"""
ctx.ensure_object(dict)
model = ctx.obj['model']
node = model['name']
if not os.path.exists(CONFIG_PATH):
click.secho(f".numerai directory not setup, run `numerai setup`...",
fg='red')
return
try:
nodes_config = load_or_init_nodes()
node_config = nodes_config[node]
provider_keys = get_provider_keys(node)
except (KeyError, FileNotFoundError) as e:
click.secho(
f"make sure you run `numerai setup` and "
f"`numerai node -n {node} config` first...",
fg='red')
return
try:
click.secho(f"deleting node configuration...")
del nodes_config[node]
store_config(NODES_PATH, nodes_config)
click.secho(f"deleting cloud resources for node...")
terraform(f'apply -auto-approve',
verbose,
env_vars=provider_keys,
inputs={'node_config_file': 'nodes.json'})
except Exception as e:
click.secho(e.__str__(), fg='red')
nodes_config[node] = node_config
store_config(NODES_PATH, nodes_config)
return
if 'model_id' in node_config and 'webhook_url' in node_config:
napi = base_api.Api(*get_numerai_keys())
model_id = node_config['model_id']
webhook_url = node_config['webhook_url']
click.echo(
f'deregistering webhook {webhook_url} for model {model_id}...')
napi.set_submission_webhook(model_id, None)
click.secho("Prediction Node destroyed successfully", fg='green')
def config_aws_keys():
aws_public, aws_secret = get_aws_keys()
aws_public = prompt_for_key('AWS_ACCESS_KEY_ID', aws_public)
aws_secret = prompt_for_key('AWS_SECRET_ACCESS_KEY', aws_secret)
check_aws_validity(aws_public, aws_secret)
keys_config = load_or_init_keys()
keys_config.setdefault('aws', {})
keys_config['aws']['AWS_ACCESS_KEY_ID'] = aws_public
keys_config['aws']['AWS_SECRET_ACCESS_KEY'] = aws_secret
store_config(KEYS_PATH, keys_config)
def config_numerai_keys():
numerai_public, numerai_secret = get_numerai_keys()
numerai_public = prompt_for_key('NUMERAI_PUBLIC_ID', numerai_public)
numerai_secret = prompt_for_key('NUMERAI_SECRET_KEY', numerai_secret)
check_numerai_validity(numerai_public, numerai_secret)
keys_config = load_or_init_keys()
keys_config.setdefault('numerai', {})
keys_config['numerai']['NUMERAI_PUBLIC_ID'] = numerai_public
keys_config['numerai']['NUMERAI_SECRET_KEY'] = numerai_secret
store_config(KEYS_PATH, keys_config)
def config(ctx, verbose, provider, size, path, example, cron, register_webhook):
"""
Uses Terraform to create a full Numerai Compute cluster in AWS.
Prompts for your AWS and Numerai API keys on first run, caches them in $HOME/.numerai.
At the end of running, this will output a config file 'nodes.json'.
"""
ctx.ensure_object(dict)
model = ctx.obj['model']
node = model['name']
model_id = model['id']
if example is not None:
path = copy_example(example, path, verbose)
# get nodes config object and set defaults for this node
click.secho(f'configuring node "{node}"...')
nodes_config = load_or_init_nodes()
nodes_config.setdefault(node, {})
nodes_config[node].update({
key: default
for key, default in DEFAULT_SETTINGS.items()
if key not in nodes_config[node]
})
# update node as needed
node_conf = nodes_config[node]
if provider:
node_conf['provider'] = provider
if size:
node_conf['cpu'] = SIZE_PRESETS[size][0]
node_conf['memory'] = SIZE_PRESETS[size][1]
if path:
node_conf['path'] = os.path.abspath(path)
if model_id:
node_conf['model_id'] = model_id
if cron:
node_conf['cron'] = cron
nodes_config[node] = node_conf
# double check there is a dockerfile in the path we are about to configure
check_for_dockerfile(nodes_config[node]['path'])
store_config(NODES_PATH, nodes_config)
# terraform apply
provider_keys = get_provider_keys(node)
click.secho(f'running terraform to provision cloud infrastructure...')
terraform(f'apply -auto-approve', verbose,
env_vars=provider_keys,
inputs={'node_config_file': 'nodes.json'})
click.secho('cloud resources created successfully', fg='green')
# terraform output for AWS nodes
click.echo(f'saving node configuration to {NODES_PATH}...')
res = terraform(f"output -json aws_nodes", verbose).decode('utf-8')
try:
aws_nodes = json.loads(res)
except json.JSONDecodeError:
click.secho("failed to save node configuration, pleas retry.", fg='red')
return
for node_name, data in aws_nodes.items():
nodes_config[node_name].update(data)
store_config(NODES_PATH, nodes_config)
if verbose:
click.secho(f'new config:\n{json.dumps(load_or_init_nodes(), indent=2)}')
webhook_url = nodes_config[node]['webhook_url']
napi = base_api.Api(*get_numerai_keys())
if not cron or register_webhook:
click.echo(f'registering webhook {webhook_url} for model {model_id}...')
napi.set_submission_webhook(model_id, webhook_url)
else:
click.echo(f'removing registered webhook for model {model_id}...')
napi.set_submission_webhook(model_id, None)
click.secho('Prediction Node configured successfully. '
'Next: deploy and test your node', fg='green')