Uploading your container using the Serverless.com framework

The Scaleway functions plugin for Serverless Framework allows users to deploy their functions and containers to Scaleway Containers with a simple serverless deploy.

Serverless Framework handles everything from creating namespaces to container deployment by calling APIs endpoint under the hood.

Creating a project folder

1. Create the following directory: ~/my-srvless-projects. Then, change into it.

   mkdir ~/my-srvless-projects
   cd ~/my-srvless-projects
   Copy code

2. Create a simple docker template by running:

   serverless create --template-url https://github.com/scaleway/serverless-scaleway-functions/tree/master/examples/container-schedule --path myService
   Copy code

   You can find other Scaleway templates on our Github.

Editing the serverless.yml file

The serverless.yml file determines the configuration of a namespace that contains one or more containers with the same runtime. In the following example, we use one container and a python3 runtime.

service: scaleway-function
configValidationMode: off
provider:
  name: scaleway
  runtime: python3, node10, node14, golang
  # Global Environment variables - used in every containers in the namespace
  env:
    test: test
  # the path to the credentials file needs to be absolute
  scwToken: <scw-token>
  scwProject: <scw-project-id>

plugins:
  - serverless-scaleway-functions

package:
  patterns:
    - '!node_modules/**'
    - '!.gitignore'
    - '!.git/**'

custom:
  containers:
    mycontainer:
      directory: my-container-directory
    minScale: 0
    maxScale: 20
    memoryLimit: 128
    # Local environment variables - used only in given container
    env: 
      example: example
    events:
      - schedule:
          rate: '1 * * * *'
          input:
            myInput: myValue
            mySecondInput: 1
Copy code

The different parameters available are:

• service: your namespace name
• provider.env: the environment variables attached to your namespace are injected into all your namespace containers
• scwToken: the Scaleway token you got in prerequisites
• scwProject: the Scaleway Project ID
• package.patterns: usually, this parameter does not need to be configured. It allows you to include or exclude directories from the deployment
• custom:
  • containers: Configuration of your containers. It is a yml dictionary, with the key being the containers’ name
  • directory (Required): directory which contains your Dockerfile and scripts
  • env (Optional): environment variables specifics for the current container
  • minScale (Optional): number of running container instances continuously (default: 0)
  • maxScale (Optional): maximum number of instances this container can scale to (default: 20)
  • memoryLimit: the RAM allocated to the container instances.
  • events (Optional): List of events that trigger your containers (e.g, trigger a container based on a schedule with CRONJobs).

Configuring your Container

List your containers under the custom.containers parameter in your serverless.yml manifest. Specify the relative path of the application directory (containing the Dockerfile, and all files related to the application to deploy) of each container:

custom:
  containers:
    mycontainer:
      directory: my-container-directory
      # Environment only available in this container 
      env:
        MY_VARIABLE: "my-value"
Copy code

The directory that contains your Dockerfile and scripts is called my-container-directory. See other files that should be included below:

.
├── my-container-directory
│   ├── Dockerfile
│   ├── requirements.txt
│   ├── server.py
│   └── (...)
├── node_modules
│   ├── serverless-scaleway-functions
│   └── (...)
├── package-lock.json
├── package.json
└── serverless.yml
Copy code

Configuring events

With events, you may link your containers to specific triggers. For the moment, the feature is limited to CRON Schedule (time-based).

Below is a list of supported triggers for Scaleway Serverless, and the configuration parameters required to deploy them:

• schedule: Triggers your container based on CRON schedules
• rate: the CRON Schedule (UNIX Format) on which your containers will be executed
• input: key-value mapping to define arguments that will be passed to your container’s event object during execution.

To link a Trigger to your container, you can define an events key in your container:

custom:
  containers:
    mycontainer:
      directory: my-directory
      # Events key
      events:
        - schedule:
            rate: '1 * * * *'
            input:
              key: value
              key2: value2
Copy code

Accessing Logs

The serverless logs command allows you to watch the logs of a specific container. Add the --function option and the container’s name to the serverless logs command to fetch the logs of a specific container.

serverless logs --function <container_name>
Copy code

Deleting a project

To remove a project run the following command:

serverless remove
Copy code

This removes all your containers, as well as your Scaleway Containers’ namespace.