Deploy applications to Container As A Service

Author: almottier

deploy/lib/createContainers.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const BbPromise = require('bluebird');
+const constants = require('./constants');
+
+module.exports = {
+  createContainers() {
+    return BbPromise.bind(this)
+      .then(this.getContainers)
+      .then(this.createOrUpdateContainers);
+  },
+
+  getContainers() {
+    const containersUrl = `namespaces/${this.namespace.id}/containers`;
+    return this.provider.apiManager.get(containersUrl)
+      .then(response => response.data.containers)
+      .catch((err) => {
+        throw new Error(err.response.data.message)
+      })
+  },
+
+  createOrUpdateContainers(foundContainers) {
+    const containers = this.provider.serverless.service.custom.containers;
+    const containerNames = Object.keys(containers);
+    const promises = containerNames.map((containerName) => {
+      const container = Object.assign(containers[containerName], { name: containerName });
+      const foundContainer = foundContainers.find(c => c.name === container.name);
+      return foundContainer ? this.updateContainer(container, foundContainer) : this.createSingleContainer(container);
+    });
+
+    return Promise.all(promises)
+      .then((updatedContainers) => {
+        this.containers = updatedContainers;
+      });
+  },
+
+  createSingleContainer(container) {
+    const params = {
+      name: container.name,
+      environment_variables: container.env,
+      namespace_id: this.namespace.id,
+      memory_limit: container.memoryLimit,
+      min_scale: container.minScale,
+      max_scale: container.maxScale,
+      timeout: container.timeout
+    };
+
+    this.serverless.cli.log(`Creating container ${container.name}...`);
+
+    return this.provider.apiManager.post('containers', params)
+      .then(response => Object.assign(response.data, { directory: container.directory }))
+      .catch((err) => {
+        throw new Error(err.response.data.message)
+      })
+  },
+
+  updateContainer(container, foundContainer) {
+    const params = {
+      redeploy: false,
+      environment_variables: container.env,
+      memory_limit: container.memoryLimit,
+      min_scale: container.minScale,
+      max_scale: container.maxScale,
+      timeout: container.timeout
+    }
+
+    const updateUrl = `containers/${foundContainer.id}`;
+    this.serverless.cli.log(`Updating container ${container.name}...`);
+    return this.provider.apiManager.patch(updateUrl, params)
+      .then(response => Object.assign(response.data, { directory: container.directory }))
+      .catch((err) => {
+        throw new Error(err.response.data.message)
+      })
+  },
+};

deploy/lib/createNamespace.js

@@ -59,6 +59,7 @@ module.exports = {
             setTimeout(() => resolve(this.waitNamespaceIsReady()), 1000);
           });
         }
+        this.saveNamespaceToProvider(response.data);
         return true;
       });
   },

deploy/lib/deployContainers.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const BbPromise = require('bluebird');
+
+module.exports = {
+  deployContainers() {
+    this.serverless.cli.log('Deploying Containers...');
+    return BbPromise.bind(this)
+      .then(this.deployEachContainer)
+      .then(() => this.serverless.cli.log('Waiting for container deployments, this may take multiple minutes...'))
+      .then(this.waitContainersAreDeployed)
+      .catch((err) => {
+        throw new Error(err.response.data.message)
+      });
+  },
+
+  deployEachContainer() {
+    const promises = this.containers.map(
+      container => this.provider.apiManager.post(`containers/${container.id}/deploy`, {})
+      .then(response => response.data)
+      .catch((err) => {
+        throw new Error(err.response.data.message)
+      }),
+    );
+
+    return Promise.all(promises);
+  },
+
+  waitContainersAreDeployed() {
+    return this.provider.apiManager.get(`namespaces/${this.namespace.id}/containers`)
+      .then((response) => {
+        const containers = response.data.containers || [];
+        let containersAreReady = true;
+        for (let i = 0; i < containers.length; i += 1) {
+          const container = response.data.containers[i];
+          if (container.status === 'error') {
+            throw new Error(container.error_message)
+          }
+          if (container.status !== 'ready') {
+            containersAreReady = false;
+            break;
+          }
+        }
+        if (!containersAreReady) {
+          return new Promise((resolve) => {
+            setTimeout(() => resolve(this.waitContainersAreDeployed()), 5000);
+          });
+        }
+
+        // Print every containers endpoint
+        return containers.forEach(container => this.serverless.cli.log(`Container ${container.name} has been deployed to: ${container.endpoint}`));
+      });
+  },
+};

deploy/lib/pushContainers.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const BbPromise = require('bluebird');
+
+const Docker = require('dockerode');
+const tar = require('tar-fs');
+const docker = new Docker();
+
+const promisifyStream = (stream, verbose) => new BbPromise((resolve, reject) => {
+    stream.on('data', data => {
+      if (verbose) {
+        console.log(data.toString().replace('\n',''))
+      }
+    })
+    stream.on('end', resolve)
+    stream.on('error', reject)
+});
+
+module.exports = {
+  pushContainers() {
+    return BbPromise.bind(this)
+      .then(this.buildAndPushContainer)
+  },
+
+
+  buildAndPushContainer() {
+    const auth = {
+      username: 'any',
+      password: this.provider.scwToken
+    }
+    
+    const containerNames = Object.keys(this.containers);
+    const promises = containerNames.map((containerName) => {
+      
+      const container = this.containers[containerName]
+      const tarStream = tar.pack(`./${container.directory}`)
+      const imageName = `${this.namespace.registry_endpoint}/${container.name}:latest`
+      this.serverless.cli.log(`Building and pushing container ${container.name} to: ${imageName} ...`);
+      return new BbPromise((resolve) => {
+          docker.buildImage(tarStream, {t: imageName})
+            .then(stream => promisifyStream(stream, this.provider.options.verbose))
+            .then(() => docker.getImage(imageName))
+            .then((image) => image.push(auth))
+            .then(stream => promisifyStream(stream, this.provider.options.verbose))
+            .then(() => resolve())
+      });
+    });
+
+    return Promise.all(promises)
+  },
+
+};

deploy/scalewayDeploy.js

@@ -3,8 +3,11 @@ const validate = require('../shared/validate');
 const setUpDeployment = require('../shared/setUpDeployment');
 const createNamespace = require('./lib/createNamespace');
 const createFunctions = require('./lib/createFunctions');
+const createContainers = require('./lib/createContainers');
+const pushContainers = require('./lib/pushContainers');
 const uploadCode = require('./lib/uploadCode');
 const deployFunctions = require('./lib/deployFunctions');
+const deployContainers = require('./lib/deployContainers');
 const namespaceUtils = require('../shared/namespace');
 
 class ScalewayDeploy {
@@ -19,11 +22,33 @@ class ScalewayDeploy {
         setUpDeployment,
         createNamespace,
         createFunctions,
+        createContainers,
+        pushContainers,
         uploadCode,
         deployFunctions,
+        deployContainers,
         namespaceUtils,
     );
 
+    function chainContainers() {
+      if (this.provider.serverless.service.custom && 
+          this.provider.serverless.service.custom.containers &&
+          Object.keys(this.provider.serverless.service.custom.containers).length !== 0) {
+        return this.createContainers()
+                .then(this.pushContainers)
+                .then(this.deployContainers)
+      }
+    };
+
+    function chainFunctions() {
+      if (this.provider.serverless.service.functions && 
+        Object.keys(this.provider.serverless.service.functions).length !== 0) {
+        return this.createFunctions()
+                .then(this.uploadCode)
+                .then(this.deployFunctions)
+      }
+    };
+
     this.hooks = {
       // Validate serverless.yml, set up default values, configure deployment...
       'before:deploy:deploy': () => BbPromise.bind(this)
@@ -35,12 +60,11 @@ class ScalewayDeploy {
       // - Create each functions in API if it does not exist
       // - Zip code - zip each function
       // - Get Presigned URL and Push code for each function to S3
-      // - Deploy each function
+      // - Deploy each function / container
       'deploy:deploy': () => BbPromise.bind(this)
           .then(this.createNamespace)
-          .then(this.createFunctions)
-          .then(this.uploadCode)
-          .then(this.deployFunctions),
+          .then(chainContainers)
+          .then(chainFunctions)
     };
   }
 }

docs/README.md

@@ -90,6 +90,7 @@ provider:
   # node8, node10 for JavaScript
   # python (2.7), python3 (3.7) for Python
   # golang
+  # You don't need to specify a runtime if you deploy only containers
   runtime: <runtime>
   # See documentation below for environment
   env:
@@ -110,10 +111,47 @@ functions:
     env:
       MY_VARIABLE: "my-value"
 ```
+### Managing containers
+
+**Requirements:** You need to have Docker installed to be able to build and push your image to your Scaleway registry.
+
+You must define your containers inside the `custom.containers` field in your serverless.yml manifest.
+Each container must specify the relative path of its application directory (containing the Dockerfile, and all files related to the application to deploy):
+
+```yml
+custom:
+  containers:
+    myContainer:
+      directory: my-container-directory
+      # Environment only available in this function
+      env:
+        MY_VARIABLE: "my-value"
+```
+
+Here is an example of the files you should have, the `directory` containing your Dockerfile ans scripts is `my-container-directory`.
+
+```
+.
+├── my-container-directory
+│   ├── Dockerfile
+│   ├── requirements.txt
+│   ├── server.py
+│   └── (...)
+├── node_modules
+│   ├── serverless-scaleway-functions
+│   └── (...)
+├── package-lock.json
+├── package.json
+└── serverless.yml
+```
+
+Scaleway's platform will automatically inject a PORT environment variable on which your server should be listening for incoming traffic. By default, this PORT is 8080.
+
+You may use the [container example](../examples/container) to getting started.
 
 ### Runtime and Functions Handler
 
-You must specify your functions runtime inside `provider.runtime` key inside your serverless.yml file.
+You must specify your functions runtime inside `provider.runtime` key inside your serverless.yml file. It is not necessary if you wish to deploy containers only.
 
 #### Runtimes
 

examples/container/my-container/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3-alpine
+WORKDIR /usr/src/app
+
+ENV PORT 8080
+EXPOSE 8080
+
+COPY requirements.txt .
+RUN pip install -qr requirements.txt
+COPY server.py .
+
+CMD ["python3", "./server.py"]

examples/container/my-container/requirements.txt

@@ -0,0 +1 @@
+Flask==1.0.2

examples/container/my-container/server.py

@@ -0,0 +1,17 @@
+from flask import Flask
+
+DEFAULT_PORT = "8080"
+MESSAGE = "Hello, World from Scaleway Container !\n"
+
+app = Flask(__name__)
+
+@app.route("/")
+def root():
+    result = MESSAGE.encode("utf-8")
+    return result
+
+if __name__ == "__main__":
+  # Scaleway's system will inject a PORT environment variable on which your application should start the server.
+  port_env =  os.getenv("PORT", DEFAULT_PORT)
+  port = int(port_env)
+  app.run(debug=True, host="0.0.0.0", port=port)

examples/container/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "container-scaleway-starter",
+    "version": "1.0.0",
+    "main": "index.js",
+    "scripts": {
+      "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {},
+    "devDependencies": {
+      "serverless-scaleway-functions": "^0.1.6"
+    },
+    "description": ""
+  }
+