Ejemplo n.º 1
0
    def deploy(self, source='', dashboard='', project='', tag='',
               kind=None):

        self.set_config('metadata.labels.mlrun/class', self.kind)
        spec = nuclio.ConfigSpec(env=self.spec.env, config=self.spec.config)
        spec.cmd = self.spec.build_commands
        kind = kind or self.spec.function_kind
        project = project or self.metadata.project or 'mlrun'
        source = source or self.spec.source
        handler = self.spec.function_handler

        if self.spec.base_spec:
            config = nuclio.config.extend_config(self.spec.base_spec, spec, tag,
                                                 self.spec.source)
            update_in(config, 'metadata.name', self.metadata.name)
            update_in(config, 'spec.volumes', self.spec.volumes)

            addr = nuclio.deploy.deploy_config(
                config, dashboard, name=self.metadata.name,
                project=project, tag=tag, verbose=self.verbose,
                create_new=True)
        else:

            name, config, code = nuclio.build_file(source, name=self.metadata.name,
                                            project=project,
                                            handler=handler,
                                            tag=tag, spec=spec,
                                            kind=kind, verbose=self.verbose)

            update_in(config, 'spec.volumes', self.spec.volumes)
            addr = deploy_config(config, dashboard_url=dashboard, name=name, project=project,
                                 tag=tag, verbose=self.verbose, create_new=True)

        self.spec.command = 'http://{}'.format(addr)
        return self.spec.command
Ejemplo n.º 2
0
    def _run(self, runobj: RunObject):

        from nuclio.deploy import deploy_config

        runtime = self.runtime
        extra_env = [{'name': 'MLRUN_EXEC_CONFIG', 'value': runobj.to_json()}]
        if self.rundb:
            extra_env.append({
                'name': 'MLRUN_META_DBPATH',
                'value': self.rundb
            })

        update_in(runtime, 'spec.env', extra_env, append=True)

        uid = runobj.metadata.uid
        update_in(runtime, 'metadata.labels.mlrun/class', self.kind)
        update_in(runtime, 'metadata.labels.mlrun/uid', uid)
        if runobj.metadata.name:
            update_in(runtime, 'metadata.name', runobj.metadata.name)
            runtime.metadata.name = runobj.metadata.name
        name = get_in(runtime, 'metadata.name', '')
        project = runobj.metadata.project

        if not project or not name:
            raise RunError(
                'name and a project must be specified in the run to deploy this function'
            )

        addr = deploy_config(runtime,
                             self.dashboard,
                             name,
                             project,
                             create_new=True)
        logger.info('function address is {}'.format(addr))
        return None
Ejemplo n.º 3
0
    def deploy(self, dashboard='', project='', tag='', kind=None):

        self.set_config('metadata.labels.mlrun/class', self.kind)
        env_dict = {
            get_item_name(v): get_item_name(v, 'value')
            for v in self.spec.env
        }
        spec = nuclio.ConfigSpec(env=env_dict, config=self.spec.config)
        spec.cmd = self.spec.build.commands or []
        project = project or self.metadata.project or 'default'
        handler = self.spec.function_handler
        if self.spec.no_cache:
            spec.set_config('spec.build.noCache', True)

        if self.spec.base_spec:
            if kind:
                raise ValueError('kind cannot be specified on built functions')
            config = nuclio.config.extend_config(self.spec.base_spec, spec,
                                                 tag,
                                                 self.spec.build.code_origin)
            update_in(config, 'metadata.name', self.metadata.name)
            update_in(config, 'spec.volumes', self.spec.to_nuclio_vol())

            logger.info('deploy started')
            addr = nuclio.deploy.deploy_config(config,
                                               dashboard,
                                               name=self.metadata.name,
                                               project=project,
                                               tag=tag,
                                               verbose=self.verbose,
                                               create_new=True)
        else:

            kind = kind if kind is not None else self.spec.function_kind
            name, config, code = nuclio.build_file(self.spec.source,
                                                   name=self.metadata.name,
                                                   project=project,
                                                   handler=handler,
                                                   tag=tag,
                                                   spec=spec,
                                                   kind=kind,
                                                   verbose=self.verbose)

            update_in(config, 'spec.volumes', self.spec.to_nuclio_vol())
            addr = deploy_config(config,
                                 dashboard_url=dashboard,
                                 name=name,
                                 project=project,
                                 tag=tag,
                                 verbose=self.verbose,
                                 create_new=True)

        self.spec.command = 'http://{}'.format(addr)
        return self.spec.command
Ejemplo n.º 4
0
def deploy_nuclio_function(function: RemoteRuntime, dashboard="", watch=False):
    function.set_config("metadata.labels.mlrun/class", function.kind)
    env_dict = {
        get_item_name(v): get_item_name(v, "value")
        for v in function.spec.env
    }
    for key, value in function._get_runtime_env().items():
        env_dict[key] = value
    spec = nuclio.ConfigSpec(env=env_dict, config=function.spec.config)
    spec.cmd = function.spec.build.commands or []
    project = function.metadata.project or "default"
    tag = function.metadata.tag
    handler = function.spec.function_handler

    # In Nuclio 1.6.0 default serviceType changed to "ClusterIP", make sure we're using NodePort
    spec.set_config("spec.serviceType", "NodePort")
    if function.spec.readiness_timeout:
        spec.set_config("spec.readinessTimeoutSeconds",
                        function.spec.readiness_timeout)
    if function.spec.resources:
        spec.set_config("spec.resources", function.spec.resources)
    if function.spec.no_cache:
        spec.set_config("spec.build.noCache", True)
    if function.spec.replicas:
        spec.set_config("spec.minReplicas", function.spec.replicas)
        spec.set_config("spec.maxReplicas", function.spec.replicas)
    else:
        spec.set_config("spec.minReplicas", function.spec.min_replicas)
        spec.set_config("spec.maxReplicas", function.spec.max_replicas)

    dashboard = dashboard or mlconf.nuclio_dashboard_url
    if function.spec.base_spec:
        config = nuclio.config.extend_config(function.spec.base_spec, spec,
                                             tag,
                                             function.spec.build.code_origin)
        update_in(config, "metadata.name", function.metadata.name)
        update_in(config, "spec.volumes", function.spec.to_nuclio_vol())
        base_image = get_in(config,
                            "spec.build.baseImage") or function.spec.image
        if base_image:
            update_in(config, "spec.build.baseImage",
                      enrich_image_url(base_image))

        logger.info("deploy started")
        name = get_fullname(function.metadata.name, project, tag)
        function.status.nuclio_name = name
        update_in(config, "metadata.name", name)
        return nuclio.deploy.deploy_config(
            config,
            dashboard,
            name=name,
            project=project,
            tag=tag,
            verbose=function.verbose,
            create_new=True,
            watch=watch,
        )
    else:

        name, config, code = nuclio.build_file(
            function.spec.source,
            name=function.metadata.name,
            project=project,
            handler=handler,
            tag=tag,
            spec=spec,
            kind=function.spec.function_kind,
            verbose=function.verbose,
        )

        update_in(config, "spec.volumes", function.spec.to_nuclio_vol())
        if function.spec.image:
            update_in(config, "spec.build.baseImage",
                      enrich_image_url(function.spec.image))
        name = get_fullname(name, project, tag)
        function.status.nuclio_name = name

        update_in(config, "metadata.name", name)
        return deploy_config(
            config,
            dashboard_url=dashboard,
            name=name,
            project=project,
            tag=tag,
            verbose=function.verbose,
            create_new=True,
            watch=watch,
        )
Ejemplo n.º 5
0
    def deploy(self, dashboard='', project='', tag='', kind=None):
        def get_fullname(config, name, project, tag):
            if project:
                name = '{}-{}'.format(project, name)
            if tag:
                name = '{}-{}'.format(name, tag)
            update_in(config, 'metadata.name', name)
            return name

        self.set_config('metadata.labels.mlrun/class', self.kind)
        env_dict = {
            get_item_name(v): get_item_name(v, 'value')
            for v in self.spec.env
        }
        spec = nuclio.ConfigSpec(env=env_dict, config=self.spec.config)
        spec.cmd = self.spec.build.commands or []
        project = project or self.metadata.project or 'default'
        handler = self.spec.function_handler
        if self.spec.no_cache:
            spec.set_config('spec.build.noCache', True)
        if self.spec.replicas:
            spec.set_config('spec.minReplicas', self.spec.replicas)
            spec.set_config('spec.maxReplicas', self.spec.replicas)
        else:
            spec.set_config('spec.minReplicas', self.spec.min_replicas)
            spec.set_config('spec.maxReplicas', self.spec.max_replicas)

        dashboard = get_auth_filled_platform_dashboard_url(dashboard)
        if self.spec.base_spec:
            if kind:
                raise ValueError('kind cannot be specified on built functions')
            config = nuclio.config.extend_config(self.spec.base_spec, spec,
                                                 tag,
                                                 self.spec.build.code_origin)
            update_in(config, 'metadata.name', self.metadata.name)
            update_in(config, 'spec.volumes', self.spec.to_nuclio_vol())
            base_image = get_in(config, 'spec.build.baseImage')
            if base_image:
                update_in(config, 'spec.build.baseImage',
                          tag_image(base_image))

            logger.info('deploy started')
            name = get_fullname(config, self.metadata.name, project, tag)
            addr = nuclio.deploy.deploy_config(
                config,
                dashboard,
                name=name,
                project=project,
                tag=tag,
                verbose=self.verbose,
                create_new=True,
            )
        else:

            kind = kind if kind is not None else self.spec.function_kind
            name, config, code = nuclio.build_file(
                self.spec.source,
                name=self.metadata.name,
                project=project,
                handler=handler,
                tag=tag,
                spec=spec,
                kind=kind,
                verbose=self.verbose,
            )

            update_in(config, 'spec.volumes', self.spec.to_nuclio_vol())
            name = get_fullname(config, name, project, tag)
            addr = deploy_config(
                config,
                dashboard_url=dashboard,
                name=name,
                project=project,
                tag=tag,
                verbose=self.verbose,
                create_new=True,
            )

        self.spec.command = 'http://{}'.format(addr)
        self.status.nuclio_name = name
        if addr:
            self.status.state = 'ready'
            self.status.address = addr
            self.save()
        return self.spec.command