{"id":16861434,"url":"https://github.com/rumpl/gosc","last_synced_at":"2026-05-06T12:49:34.705Z","repository":{"id":66257860,"uuid":"273736247","full_name":"rumpl/gosc","owner":"rumpl","description":null,"archived":false,"fork":false,"pushed_at":"2020-06-20T15:40:52.000Z","size":72,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":3,"default_branch":"master","last_synced_at":"2025-01-24T23:14:33.777Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/rumpl.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2020-06-20T15:40:19.000Z","updated_at":"2020-06-20T15:40:55.000Z","dependencies_parsed_at":"2023-02-21T09:01:04.002Z","dependency_job_id":null,"html_url":"https://github.com/rumpl/gosc","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rumpl%2Fgosc","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rumpl%2Fgosc/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rumpl%2Fgosc/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rumpl%2Fgosc/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/rumpl","download_url":"https://codeload.github.com/rumpl/gosc/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":244305603,"owners_count":20431735,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-10-13T14:31:58.944Z","updated_at":"2026-05-06T12:49:29.668Z","avatar_url":"https://github.com/rumpl.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Go API client for openapi\n\n# Introduction\n\nScaleway Functions is a `Function As A Service` product which gives users the ability to deploy atomic serverless workloads and only pay for resources used while functions are running.\n\nIt provides many advantages, such as:\n\n- Functions are only executed when a event is triggered, which allows users to save money while code is not running\n- Auto-Scalability:\n  - Automated `Scaling up and down` based on user configuration (e.g. min: 0, max: 100 replicas of my function).\n  - Automated `Scaling to zero` when function is not executed, which saves some money for the user and save Computing resources for the cloud provider.\n- Scale only the endpoint\n\n## Main features\n\n- Fully isolated environments\n- Scaling to zero (save money and computing resources while code is not executed)\n- High Availability and Scalability (Automated and configurable, each function may scale automatically according to incoming workloads)\n- Runtimes for the following programming languages:\n  - Golang\n  - node.js v8 and v10\n  - Python v2.7 and v3.7\n  - Container As A Service: deploy any non-root container listening on port \\\\$PORT\n- Multiple event sources:\n  - HTTP (request on our Gateway will execute the function)\n  - CRON (time-based job, runs according to configurable cron schedule)\n- Integrated with the Scaleway Container Registry product\n  - Each of your functions namespace has an associated registry namespace\n  - All your functions are available as docker image in this registry namespace\n  - Each version of your function matches a tag of this image\n\n# Scaleway Functions Components\n\n## Namespaces\n\nA `Namespace` is basically a project, a group of `functions`, in which you may set-up `environment variables` to use in each function.\n\n**Please Note** that Scaleway Functions operates upon `Kubernetes`, so we use `Docker` container technology to execute user's code.\n\nTherefore, we integrate our APIs with `Scaleway's Container Registry` product to store user's docker images. **Each Namespace gets a Container Namespace** in which functions images will be pushed.\n\n## Functions\n\nA `Function` in Scaleway Functions consists of multiple components:\n\n- A `Runtime` (Golang, Python 2/3, Node 8/10...), basically the programming language/environment in which your code will be executed.\n- `Environment Variables`: You may configure specific environment variables (Database host/credentials for example) which are safely encrypted in our Database, and will be mounted inside your Functions. **Note** that environment variables set at `Namespace` level will also be mounted (in every function). Environment variables written at `function` level override the ones set at `namespace` level (if two env var have the same name for example).\n- `Source code`: In order to run in the cloud, a function must contain user's source code based on the programming language chosen in `runtime` variable.\n- `Resources`: users may decide how much computing resources to allocate to each function -\u003e `Memory Limit` (in MB). We will then allocate the right amount of `CPU` based on Memory Limit choice. The right choice for your functions's resources is very important, as you will be billed based on compute usage over time and the number of functions executions.\n\nRepresentation of given CPU resources based on configured Memory Limit (in MB) for a function:\n\n| Memory (in MB) | CPU  |\n| :------------: | :--: |\n|      128       | 70m  |\n|      256       | 140m |\n|      512       | 280m |\n|      1024      | 560m |\n\nWhere 560mCPU accounts roughly for half of one CPU power of a Scaleway General Purpose instance\n\nSupported runtimes:\n\n- node8\n- node10\n- python2\n- python3\n- golang 1.11+\n\n## Containers\n\nContainers are applications you deploy with your own runtime:\n\n- Create a docker image\n- Create a container\n- Push your image in your registry namespace\n- Deploy\n\nThey are used, scaled and billed like functions\n\n## CRON\n\nA `CRON` is a type of event which triggers a Scaleway Function (or Container), it is an `add-on` to your function.\n\nCRONs inside Scaleway Serverless have the following properties:\n\n- `schedule`: UNIX Formatted CRON schedule. Your function will be executed based on this schedule. For example, `5 4 * * 0` means execute my function at \\\"04:05 AM\\\" on each Sunday (see this [page from Ubuntu's official documentation](https://doc.ubuntu-fr.org/cron)).\n- `args`: JSON Object passed to your function. You can use this property to define data that will be passed to your function's `event.body` object. For Containers, you might handle these arguments as the HTTP Request's Body.\n\nUnder the hood, CRON Triggers are [Kubernetes JOBs](https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/) sending HTTP POST requests to your function/container.\n\nTo deploy a CRON Function, you must first:\n\n- Create a Namespace\n- Deploy a function (or a container)\n- Create a CRON and associate it with the created/deployed function.\n\n## Authentication\n\nBy default, creating a function or a container will make it `public`, meaning that anybody knowing the endpoint could execute it.\n\nA function or a container can be made `private` with the `privacy` parameter.\n\nHere is the workflow used to authenticate to a `private` Scaleway Function:\n\n- Create a function with privacy `private`\n- Deploy your function\n- Generate a specific `token` from our API\n- Send a request to your function and provide the generated token (all unauthenticated requests will be rejected).\n\n### Tokens\n\nPrivacy works with JWT tokens. A JWT Token can be retrieved from the endpoint GET `/jwt/issue`. Depending on the parameters, a jwt token can be valid for either a function, a container, or a namespace:\n\n- `/jwt/issue?namespace_id=1`: issues JWT valid for all functions inside namespace with ID `1`.\n- `/jwt/issue?function_id=1`: issues JWT valid only for function with id `1`.\n- `/jwt/issue?container_id=1`: issues JWT valid only for container with id `1`.\n\n**Note that you may (optional) provide an expiration date (formatted \\\"yyyy-mm-ddT00:00:00Z\\\") for the token**: example `/jwt/issue?expiration_date=2020-01-02T00:00:00Z\u0026namespace_id=1` will generate a token, valid for all functions and containers inside Namespace with id `1`, and this token will be valid until January 2nd 2020.\n\nThe token will have the following claims:\n\n```json\n{\n  \\\"application_claim\\\": [\n    {\n      \\\"namespace_id\\\": \\\"string\\\",\n      \\\"application_id\\\": \\\"string\\\" // optional: id of function/container\n    }\n  ]\n}\n```\n\nTokens are not stored by Scaleway and can not be retrieved if lost (but new tokens can be generated).\n\nToken revocation is not yet supported, the best way to reset the tokens is to destroy and recreate the namespaces and all of its functions.\n\n### Functions\n\nA `private` function observes this behaviour:\n\n- If a call is done without `SCW_FUNCTIONS_TOKEN` header, the call is rejected (`Status Code 404`)\n- If `SCW_FUNCTIONS_TOKEN` header is provided, the token is validated using a public key attached to the namespace.\n\nThe environment variables `SCW_PUBLIC`, `SCW_PUBLIC_KEY`, `SCW_NAMESPACE_ID`, `SCW_APPLICATION_ID` are provided by our APIs to validate incoming tokens.\n\nFor example, to execute a private function by providing a JWT using `curl`, you may run the following command:\n\n```bash\ncurl -H \\\"SCW_FUNCTIONS_TOKEN: \u003cgenerated-token\u003e\\\" \u003cyour-function-host\u003e\n```\n\n### Containers\n\nAs the token validation is done in the function runtime, marking a container as `private` will not do the actual authentication.\n\nInstead, it will set the following environment variables, which you can use in your application to validate incoming requests (token provided by our APIs):\n\n- `SCW_PUBLIC`: `true` or `false` based on your privacy settings\n- `SCW_PUBLIC_KEY`: PEM-encoded public Key used to decrypt tokens\n- `SCW_NAMESPACE_ID`: Current Namespace ID\n- `SCW_APPLICATION_ID`: Current Container ID\n\nAs described above, tokens generated from our API will contain either `namespace id` or `application id` in its claims, so you may verify it's validity (after decrypting the JWT with the inject `SCW_PUBLIC_KEY`).\n\n## Logs\n\nFunctions and containers output logs can be retrieved from the endpoint GET `/logs`. You need to pass its ID as an `application_id` parameter.\n\n# Quick Start Guide\n\n## Pre-requisites\n\nWhether you decide to use Serverless Framework or directly our API, you'll need your Scaleway Organization ID and a Scaleway\nOrganization Access Key.\n\n- Install `curl`\n- Install `jq` will make it easier to manage JSON output from our APIs\n\nTo call Scaleway API, you need an `X-Auth-Token`. If you don't have one yet, you can create it on the [credentials page](https://cloud.scaleway.com/#/credentials) of your Scaleway account (must be done via web interface).\n\nIn order to retrieve your `Organization ID` and your `secret Key`, you must go to your [console's credentials page](https://console.scaleway.com/account/credentials):\n\n- Login/Register to [Scaleway console](https://console.scaleway.com)\n- Go to your [credentials management page](https://console.scaleway.com/account/credentials)\n- Retrieve your `organization ID` and generate a token (see following picture):\n  ![credentials section](https://functions-doc.s3.fr-par.scw.cloud/credentials_section.png)\n- Retrieve your token's `secret key`:\n  ![token secret key](https://functions-doc.s3.fr-par.scw.cloud/secret_key.png)\n\nThen, export then as variables to use them with curl\n\n```bash\nexport TOKEN=\\\"\u003cSecret key of your token\u003e\\\"\n# Only available in fr-par at the moment\nexport REGION=\\\"\u003cchoose your location (nl-ams/fr-par)\u003e\\\"\nexport ORGANIZATION_ID=\\\"\u003cyour organization ID\u003e\\\"\n```\n\n## Serverless Framework\n\nThe following sections explain how to use our API, with a tutorial and the auto-generated API documentation. However, we developed a [Serverless Framework plugin](https://github.com/scaleway/serverless-scaleway-functions) enabling users to deploy their serverless workloads much more easily with a single `serverless deploy` command. No magic there, it's just a nice tool calling our API.\n\nIf what you are looking for is an easy way to deploy your code, you may prefer Serverless Framework.\n\nBelow, you will find a step-by-step guide on how to create a `namespace`, configure and deploy `functions`, and trigger your `functions` via HTTP and CRON.\n\n## Create a Namespace\n\nCustomize the name and set your organization ID\n\n```bash\n\ncurl -X POST \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/namespaces\\\" -H \\\"accept: application/json\\\" -H \\\"X-Auth-Token: $TOKEN\\\" -H \\\"Content-Type: application/json\\\" \\\\\n-d \\\"{\\\\\\\"name\\\\\\\": \\\\\\\"your-namespace-name\\\\\\\", \\\\\\\"organization_id\\\\\\\": \\\\\\\"$ORGANIZATION_ID\\\\\\\", \\\\\\\"environment_variables\\\\\\\": {\\\\\\\"YOUR_VARIABLE\\\\\\\": \\\\\\\"content\\\\\\\"}}\\\"\n```\n\nCopy the `id` field of the response to use at the next steps. For the sake of simplicity we will save the ID to a variable, which we will use in the following examples:\n\n```bash\nexport NAMESPACE_ID=\\\"\u003cyour namespace id\u003e\\\"\n```\n\nTo destroy a namespace (along with all functions and crons) use the following call:\n\n```bash\ncurl -s -H \\\"X-Auth-Token: $TOKEN\\\" -X DELETE \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/namespaces/$NAMESPACE_ID\\\"\n```\n\n## Write a function handler\n\n**Please note that our runtimes are AWS Lambda Compatible**, which means that we respect Lambda's format (event, context and callback parameters hold the same keys as AWS Lambda's).\nBe careful about `context` though, as we do not provide the exact same keys as Lambda (we don't have cognito services for example).\n\nFor this example, we'll be using `node10` runtime:\n\n```bash\ntouch handler.js\n```\n\nAnd inside `handler.js` file:\n\n```javascript\n// handler.js\nmodule.exports.myHandler = async (event, context, callback) =\u003e {\n  const response = {\n    body: JSON.stringify({message: \\\"Hello, World\\\"}),\n    statusCode: 200,\n    headers: {\n      MY_HEADER: \\\"its content\\\",\n    },\n  }\n  return response\n}\n```\n\n## Create a function\n\nWhen creating a function, you may customize multiple fields:\n\n- `name`: The name of your function\n- `namespace_id`: ID of the namespace in which you want to create your function\n- `runtime`: Your function's runtime, check the supported runtimes above\n- `memory_limit`: Memory (in MB) allocated to your function, see the table of memory/CPU allocation above (increasing the memory limit will increase the cost of your function executions as we allocate more resources to your functions).\n- `min_scale`: Minimum replicas for your function, defaults to `0`, **Note** that a function is `billed` when it gets executed, and using a `min_scale` greater than 0 will cause your function to run all the time.\n- `max_scale`: Maximum replicas for your function (defaults to `20`), our system will scale your functions automatically based on incoming workload, but will never scale the number of replicas above the configured `max_scale`.\n- `handler` (More details with examples in each language/runtime section below):\n  - `Python`: Path to function handler's file and the function to use as the handler: `src/handler.my_handler` =\u003e file `handler.py` defining a `my_handler` function, inside `src` folder.\n  - `Node`: Path to function handler's file, suffixed the name of the function to use as the handler: `src/handler.myHandler` =\u003e file `handler.js` exporting a `myHandler` function, inside `src` directory.\n  - `Golang`: Path to the package containing the handler: `my_handler`: the code containing the handler is located inside a `my_handler` directory (must be `package main`, and exposing a `main function`).\n\n```bash\ncurl -X POST \\\\\n-H \\\"X-Auth-Token: $TOKEN\\\"\\\\\n\\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/functions\\\"\\\\\n-d \\\"{\\\\\\\"name\\\\\\\": \\\\\\\"function-name\\\\\\\", \\\\\\\"namespace_id\\\\\\\": \\\\\\\"$NAMESPACE_ID\\\\\\\", \\\\\\\"memory_limit\\\\\\\": 128, \\\\\\\"min_scale\\\\\\\": 0, \\\\\\\"max_scale\\\\\\\": 20, \\\\\\\"runtime\\\\\\\": \\\\\\\"node10\\\\\\\", \\\\\\\"handler\\\\\\\": \\\\\\\"handler.myHandler\\\\\\\"}\\\"\nexport FUNCTION_ID = \\\"\u003cyour-function-id\u003e\\\"\n```\n\n## Upload your source code (Scaleway runtime)\n\nThese steps only apply if you use a Scaleway runtime. In this section, you will upload your code to a S3 bucket, which\nwe'll package and build into a container image.\n\nThis container image will then be available in a registry namespace associated to your functions namespace.\n\n### Archive your code\n\n```bash\nexport FUNCTION_ARCHIVE=\\\"function-$FUNCTION_ID.zip\\\"\n```\n\nYou may then create a zip archive with your code:\n\n```bash\nzip $FUNCTION_ARCHIVE handler.js\n```\n\n**Please Note that if you wish to use external dependencies, you will have to package them inside the zip archive as well**:\n\n```bash\nzip -r $FUNCTION_ARCHIVE package.json handler.js node_modules\n```\n\n### Get a presigned URL for our S3 Bucket to store your function handler\n\nYou need to get the size of your archive in bytes, in order to ask for a presigned URL to upload your source code:\n\n```bash\nls -lh\n-rw-r--r--  1 user  group   675 Apr 18 15:42 $FUNCTION_ARCHIVE\n\nexport ARCHIVE_SIZE=675\n```\n\n```bash\ncurl -X GET -H \\\"X-Auth-Token: ${TOKEN}\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/functions/$FUNCTION_ID/upload-url?content_length=$ARCHIVE_SIZE\\\"\n\n# Example of response from our API\n{\\\"url\\\":\\\"https://s3.fr-par.scw.cloud/scw-database-srvless-prod/uploads/function-b0525a73-947d-4ba4-92de-17f267a7ec5a.zip?X-Amz-Algorithm=AWS4-HMAC-SHA256\\\\u0026X-Amz-Credential=SCW6Z6VKJVG81FQZVB14%2F20190627%2Ffr-par%2Fs3%2Faws4_request\\\\u0026X-Amz-Date=20190627T092839Z\\\\u0026X-Amz-Expires=3600\\\\u0026X-Amz-SignedHeaders=content-length%3Bcontent-type%3Bhost\\\\u0026X-Amz-Signature=e9f3e22f39638dac047f0f4e9ab521c7971cacb01f61f523cb948baa328a0eff\\\",\\\"headers\\\":{\\\"content-length\\\":[\\\"347\\\"],\\\"content-type\\\":[\\\"application/octet-stream\\\"]}}\n```\n\nAs you can see, the url is not properly formatted (\\\\u0026...), in order to use it properly to upload your code, you must\ncopy the full URL with quotes (otherwise your terminal might add unwanted \\\\ in the url string):\n\n```bash\nexport FUNCTION_ARCHIVE_URL=$(echo -n \\\"\u003cyour-url\u003e\\\")\n```\n\n**Note**: that you will get an error in the following step if you do not Copy the url with wrapping quotes and save inside a variable using echo -n to replace \\\\u0026 expressions\n\nIf you use postman, you can usually export the presigned url as it is, as long as you copy/paste the quotes too.\n\n### Upload your code to the presigned URL\n\n```bash\ncurl -H \\\"Content-Type: application/octet-stream\\\" --upload-file $FUNCTION_ARCHIVE -H \\\"Content-Length: $ARCHIVE_SIZE\\\" $FUNCTION_ARCHIVE_URL\n```\n\n## Deploy a function\n\nThen, run the following command to deploy your function:\n\n```bash\ncurl -X POST -H \\\"X-Auth-Token: $TOKEN\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/functions/$FUNCTION_ID/deploy\\\" -d \\\"{}\\\"\n```\n\nThe process may take a little bit of time, as we have to build your source code into an executable function (wrapped by our runtimes), and deploy it to our cloud platform.\n\n## Trigger your function\n\nOnce your function has been properly deployed, you may retrieve your function's HTTP(s) endpoint with the following command:\n\n```bash\ncurl -X GET -H \\\"X-Auth-Token: $TOKEN\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/functions/$FUNCTION_ID\\\"\n\nexport FUNCTION_ENDPOINT=\\\"\u003cendpoint\u003e\\\"\n```\n\nAnd then, call your function via its endpoint:\n\n```bash\ncurl -X GET \\\"$FUNCTION_ENDPOINT\\\"\n```\n\n## Get your functions logs\n\nTo retrieve the functions output logs:\n\n```bash\ncurl -X GET -H \\\"X-Auth-Token: $TOKEN\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/logs?application_id=$FUNCTION_ID\\\"\n```\n\n## Create a CRON Trigger for your Function\n\nAs described above, `CRON` triggers are a way to execute your applications (Functions and Containers) periodically, based on a given Schedule.\n\nIt means that we can execute our function every day at 1PM for example, with a given set of data.\n\nIn order to add a `CRON` Trigger to your function, you need to retrieve your function ID (Done previously if you followed the guide), and create a new CRON associated to your function:\n\n```bash\ncurl -X POST -H \\\"X-Auth-Token: $TOKEN\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/crons\\\" -d \\\"{\\\\\\\"application_id\\\\\\\": \\\\\\\"$FUNCTION_ID\\\\\\\", \\\\\\\"schedule\\\\\\\": \\\\\\\"0 13 * * *\\\\\\\", \\\\\\\"args\\\\\\\": {\\\\\\\"key\\\\\\\": \\\\\\\"value\\\\\\\"}}\\\"\n```\n\nThe above request will create and deploy a Kubernetes CRON Job in charge of executing your function every day at 13:00, with the data `{\\\"key\\\": \\\"value\\\"}`, retrieved from the `event.body` object in your handler.\n\n**Note that this step is also applicable to containers, you just need to pass your container ID as the CRON's `application_id` property**.\n\n## Create a container\n\nCreating a container is nearly identical to creating a function.\n\nThe main difference is that here you don't need to upload your code in a S3 bucket. Instead, you need to build it as a docker image and push it to\nour registry.\n\n```bash\ncurl -X POST \\\\\n-H \\\"X-Auth-Token: $TOKEN\\\" \\\\\n\\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/containers\\\" \\\\\n-d \\\"{\\\\\\\"name\\\\\\\": \\\\\\\"container-name\\\\\\\", \\\\\\\"namespace_id\\\\\\\": \\\\\\\"$NAMESPACE_ID\\\\\\\", \\\\\\\"memory_limit\\\\\\\": 128, \\\\\\\"min_scale\\\\\\\": 0, \\\\\\\"max_scale\\\\\\\": 20}\\\"\n```\n\nLet's export the container_name for later:\n\n```bash\nexport CONTAINER_NAME=\\\"\u003ccontainer_name\u003e\\\"\nexport CONTAINER_ID=\\\"\u003ccontainer_id\u003e\\\"\n```\n\n### Get your registry namespace\n\nFirst, get your registry_namespace_id\n\n```bash\ncurl -X GET -H \\\"X-Auth-Token: ${TOKEN}\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/namespaces/$NAMESPACE_ID\\\"\nexport REGISTRY_NAMESPACE_ID=\\\"\u003cregistry-namespace-id\u003e\\\"\n```\n\nSecondly, get your registry name\n\n```bash\ncurl -X GET -H \\\"X-Auth-Token: ${TOKEN}\\\" \\\"https://api.scaleway.com/registry/v1beta2/regions/$REGION/namespaces/$REGISTRY_NAMESPACE_ID\\\"\nexport REGISTRY_ENDPOINT=\\\"\u003cendpoint\u003e\\\"\n```\n\n### Push your image\n\nWe suppose you already have a working image here. It can be anything which listens on a env variable \\\\$PORT variable.\nNote that we run your container as user 1000, not root, so it must be runnable under these conditions\n\nTo push your image, we invite you to check the container registry documentation.\n\n```bash\ndocker login $REGISTRY_ENDPOINT -u userdoesnotmatter -p $TOKEN\ndocker tag myimage $REGISTRY_ENDPOINT/${CONTAINER_NAME}:latest\ndocker push $REGISTRY_ENDPOINT/${CONTAINER_NAME}:latest\n```\n\n### Deploy a container\n\n```bash\ncurl -X POST -H \\\"X-Auth-Token: $TOKEN\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/containers/$CONTAINER_ID/deploy\\\" -d \\\"{}\\\"\n```\n\n## Trigger your container\n\n```bash\ncurl -X GET -H \\\"X-Auth-Token: $TOKEN\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/containers/$CONTAINER_ID\\\"\nexport CONTAINER_ENDPOINT=\\\"\u003cendpoint\u003e\\\"\n\ncurl -X GET \\\"$CONTAINER_ENDPOINT\\\"\n```\n\n## Get your containers logs\n\nTo retrieve the containers output logs:\n\n```bash\ncurl -X GET -H \\\"X-Auth-Token: $TOKEN\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/logs?application_id=$CONTAINER_ID\\\"\n```\n\n# Writing code\n\nRuntimes are environment that you may use to develop their cloud functions.\n\nScaleway Runtimes are `Lambda Compatible` -\u003e For API Gateway Proxy `event types` (as we only support HTTP and CRON, but cron basically sends HTTP requests to deployed functions).\n\nIn a common use case with `Serverless Framework` for example, in which a user has multiple functions in the same repository and would like to upload them all at the same time with a single command, we need a way to know, which file (Python/JavaScript) or package (Golang) to use to execute our functions.\n\n**Please Note** that in some runtimes, this `decision` is made at runtime (Python and JavaScript, as they are interpreted languages, so our runtime will only `import` the handler), while in some others (Golang), it is done at compile/build time (when user `deploys` a function) as we need to build user's package.\n\n## Node (v8, v10)\n\n### Node handler function\n\n**Please Note** currently function handler must be a named exported component =\u003e `module.exports.myHandler = (event, context, callback) =\u003e {}`\n\nThere are multiple ways to return a response from a handler function:\n\nFirst one: `return object with body and statusCode` will set the status code as HTTP Response Code, and body as the Response's body, headers as Headers.\n\n- Stringified **body** (like `AWS Lambda`):\n\n```javascript\nmodule.exports.myHandler = (event, context, callback) =\u003e {\n  return {\n    statusCode: 201,\n    body: JSON.stringify({\n      message: \\\"async function\\\",\n    }),\n    headers: {\n      \\\"Content-Type\\\": \\\"application/json\\\",\n    },\n  }\n}\n```\n\n- **Not** Stringified **body** (like `AWS Lambda`):\n\n```javascript\nmodule.exports.myHandler = (event, context, callback) =\u003e {\n  return {\n    statusCode: 201,\n    body: {\n      message: \\\"async function\\\",\n    },\n    headers: {\n      \\\"Content-Type\\\": \\\"application/json\\\",\n    },\n  }\n}\n```\n\nSecond: `return Object/entity (number, boolean, string...) withtout properties body and statusCode` will return the response `as is`:\n\n```javascript\nmodule.exports.myHandler = (event, context, callback) =\u003e {\n  return {\n    message: \\\"message\\\",\n  }\n\n  // Or\n  return JSON.stringify({message: \\\"message\\\"})\n  // OR\n  return \\\"Hello, world\\\"\n  // OR\n  return 1 // true,false,undefined,null...\n}\n```\n\n`Use Callback parameter`:\n\n```javascript\nmodule.exports.myHandler = (event, context, callback) =\u003e {\n  const response = {\n    statusCode: 201,\n    body: {\n      message: \\\"async function\\\",\n    },\n    headers: {\n      \\\"Content-Type\\\": \\\"application/json\\\",\n    },\n  }\n\n  // Successful response\n  callback(undefined, response)\n  // Error response\n  callback(err)\n}\n```\n\n**Note that you may use life changing async in handlers** :)\n\n`return a Promise`:\n\n```javascript\nmodule.exports.myHandler = async (event, context, callback) =\u003e {\n  return {\n    statusCode: 201,\n    body: {\n      message: \\\"async function\\\",\n    },\n    headers: {\n      \\\"Content-Type\\\": \\\"application/json\\\",\n    },\n  }\n}\n\n// OR\nmodule.exports.myHandler = (event, context, callback) =\u003e {\n  const response = {\n    statusCode: 201,\n    body: {\n      message: \\\"async function\\\",\n    },\n    headers: {\n      \\\"Content-Type\\\": \\\"application/json\\\",\n    },\n  }\n\n  return new Promise((resolve, reject) =\u003e {\n    // do something\n    if (err) return reject(err)\n    return resolve(response)\n  })\n}\n```\n\n### Node handler name\n\nThe Handler name is basically a path to the handler file.\n\nFor example, let's say I have two handlers `hello.js` and `world.js` inside `src/handlers` folder:\n\n```\nsrc\n-- handlers\n---- hello.js =\u003e module.exports.sayHello\n---- world.js =\u003e module.exports.toTheWorld\n```\n\nThen, you need to provide a custom handler name for each of these handlers, so each of your functions will know which handler file to run: `hello` -\u003e `src/handlers/hello.sayHello` and `world` -\u003e `src/handlers/world.toTheWorld`.\n\n**By default**, the handler path is `handler.handle` (`module.exports.handle` in handler.js).\n\n### Node additional dependencies\n\nIf you ever need to push external dependencies for your node.js functions, you will have to package your `node_modules` directory into your deployment archive.\n\n```\n-- handler.js\n-- node_modules\n---- \u003cyour-dependencies\u003e\n```\n\nYou may definitely use tools such as `webpack` or [NCC](https://github.com/zeit/ncc) (CLI tool to build node.js executables, inspired from `go` CLI), which will package your code into separate files, you will then be able to upload your compiled handler file, which reduces the size of your bundle.\n\nExample:\n\n```bash\nncc handler.js -o build/handler.js # -\u003e Builds dist/inde\n```\n\nThen, set up your `function handler` to be: `build/handler.js` if you package the whole `build` directory.\nDon't forget to point the `function handler` property to the path of your built handler in your archive (if `build/handler.myHandler` then `handler must be build/handler.js`)\n\n## Golang\n\n**Only versions 1.11+ are supported on Scaleway Serverless**\n\n### Golang handler function\n\n**Please Note** that every handler must be in its package, identified by `package main`, and exporting a main function with the following `lambda.Start` statement:\n\n```golang\n// Must Always be package main\npackage main\n\n// Import both packages events and lambda from scaleway-functions-go library\nimport (\n \\\"encoding/json\\\"\n \\\"github.com/scaleway/scaleway-functions-go/events\\\"\n \\\"github.com/scaleway/scaleway-functions-go/lambda\\\"\n)\n\n// Handler - Your handler function, uses APIGatewayProxy event type as your function will always get HTTP formatted events, even for CRON\nfunc Handler(req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {\n return events.APIGatewayProxyResponse{\n  Body:       \\\"Your response\\\",\n  StatusCode: 200,\n }, nil\n}\n\n// Main function is mandatory -\u003e Must call lambda.Start(yourHandler) otherwhise your handler will not be called properly.\nfunc main() {\n lambda.Start(Handler)\n}\n```\n\n### Golang handler name\n\nIn Golang, as it is a `compiled` language, you need to provide Scaleway Function API with a `handler name` pointing to the function's directory.\n\n```\nsrc\n-- handlers\n---- hello\n------ go.mod\n------ go.sum\n------ main.go -\u003e package main in \\\"handlers/hello\\\" subdirectory\n---- world\n------ go.mod\n------ go.sum\n------ main.go -\u003e package main in \\\"handlers/workd\\\" subdirectory\nhandler.go -\u003e package main at the root of serverless project\ngo.mod\ngo.sum\n```\n\nThen, you need to provide a custom handler name for each of these handlers, so each of your function will know which handler file to run: `hello` -\u003e `handlers/hello`, `world` -\u003e `handlers/world`, and for the `handler.go` at the root of the project -\u003e `.`\n\n**By default**, the handler path is `.` (`package main` at the root of the archive).\n\n### Golang additional dependencies\n\nIf you need external dependencies for your `Golang handlers`, you may provide these dependencies by using `Go Modules`:\n\n- Our runtimes automatically installs your dependencies at Build time (Once you start the function `deployment`). **Note that dependencies installation at build-time will result in longer builds**.\n\n  ```\n  -- handler.go\n  -- go.mod\n  -- go.sum\n  ```\n\n- You may package your dependencies with the command `go mod vendor`, and provide your generated `vendor` directory to the function archive. **This approach will save you some time during builds**:\n  ```\n  -- handler.go\n  -- go.mod\n  -- go.sum\n  -- vendor # Dependencies should be installed inside your vendor directory\n  ---- \u003cyour-dependencies\u003e\n  ```\n\n## Python\n\n### Python handler function\n\nThere are multiple ways to return a response from a handler function:\n\n- Classical response object with `HTTP` informations:\n\n```python\ndef my_handler(event, context):\n    return {\n        \\\"body\\\": {\n            \\\"test\\\": \\\"test\\\"\n        },\n        \\\"statusCode\\\": 200,\n        \\\"headers\\\": {\n            \\\"your-header\\\": \\\"your-value\\\"\n        }\n    }\n```\n\n- Straight response without `body`:\n\n```python\ndef my_handler(event, context):\n    return {\\\"message\\\": \\\"whatever\\\"}\n    # or\n    return \\\"my Message\\\"\n```\n\n- Stringified response **body** (`AWS Lambda`):\n\n```python\nimport json\n\ndef my_handler(event, context):\n  return {\n    \\\"body\\\": json.dumps({\\\"message\\\": \\\"Hello\\\"}),\n    \\\"statusCode\\\": 200,\n  }\n```\n\n### Python handler name\n\nThe Handler name is basically a path to the handler file, suffixed with the function name to use as a handler.\n\nFor example, let's say you have two handlers `hello.py` and `world.py` inside `src/handlers` folder:\n\n```\n src\n-- handlers\n---- hello.py =\u003e def say_hello\n---- world.py =\u003e def to_the_world\n```\n\nThen, you need to provide a custom handler name for each of these handlers, so each of your functions will know which handler file to run: `hello` -\u003e `src/handlers/hello.say_hello` and `world` -\u003e `src/handlers/world.to_the_world`.\n\n**By default**, the handler path is `handler.handle` (def `handle` in handler.py).\n\n### Python additional dependencies\n\nAdditional dependencies must be included inside a `package` directory at the root of your archive/project:\n\n```bash\n# At the root of your archive\nmkdir package\n```\n\n```\n- requirements.txt\n- handlers\n--- handler.py =\u003e import requests\n--- secondHandler.py =\u003e import requests\n- package\n--- requests\n--- ...\n```\n\n#### Standard dependencies\n\nYou may install your dependencies to the `package` directory:\n\n```bash\npip install requests --target ./package\n```\n\nOr with a `requirements.txt` file:\n\n```bash\npip install -r requirements.txt --target ./package\n```\n\n#### Specific libraries (with needs for specific C compiled code)\n\nIn some cases, you might need to install libraries which require specific C compiled code such as (for example):\n\n- `numpy`\n- `tensorflow`\n- `pandas`\n- `scikit-learn`\n- ...\n\nOur Python runtimes run on top of `alpine linux` environments, for these specifics dependencies, you will have to install your dependencies inside a `docker container`, with a specific image, that we are providing to our users.\n\nYou may run the following command from the root of your project to install your dependencies before uploading your source code and deploying your function:\n\n```bash\ndocker run --rm -v $(pwd):/home/app/function --workdir /home/app/function rg.fr-par.scw.cloud/scwfunctionsruntimes/python-dep3:v4.0.0 pip install -r requirements.txt --target ./package\n```\n\nThis command will run `pip install` with given `requirements.txt` file inside a `docker container` compatible with our function runtimes, and pull the installed dependencies locally to your `package` directory.\nAs these dependencies have been installed on top of `alpine linux` with our compatible `system libraries`, you will be able to upload your source code and deploy your function properly.\n\n**Note** that the example below uses `python3` runtime, but you can easily change the docker image from `rg.fr-par.scw.cloud/scwfunctionsruntimes/python-dep3:v4.0.0` to `rg.fr-par.scw.cloud/scwfunctionsruntimes/python-dep2:v4.0.0`\n\n## Remove a Scaleway Functions namespace (Project)\n\nWhen deleting a Functions Namespace, we take care of removing all sub-resources such as `Functions` and `CRONs` deployed in this namespace.\n\n- With `Serverless Framework`:\n\n```bash\nserverless remove\n```\n\n- With `curl`:\n\n```bash\ncurl -X DELETE -H \\\"X-Auth-Token: ${TOKEN}\\\" \\\"https://api.scaleway.com/functions/v1alpha2/regions/$REGION/namespaces/$NAMESPACE_ID\\\"\n```\n\n**Please note** that deleting a `Scaleway Functions` namespace will not automatically delete Scaleway Container Registry namespaces linked to your FAAS project. It is your responsibility to manually remove your Registry namespaces via Scaleway Console or API.\n\n## Develop Locally\n\nIf you are using either `node` or `python` runtimes, you may use our [Offline Gateway plugin](https://github.com/scaleway/serverless-offline-scaleway) (Developed and maintained by Scaleway).\n\n```bash\nnpm install --save-dev serverless-offline-scaleway\n```\n\nAnd in your serverless File:\n\n```yml\nplugins:\n  - serverless-scaleway-functions\n  - serverless-offline-scaleway\n```\n\nYou may now invoke your functions locally via the following command line:\n\n```bash\nserverless offline start\n```\n\n## API Reference\n\n### Event\n\n#### Node/Python\n\n- `pathParameters`: map(string)string - Parameters defined in the path of the HTTP Request\n- `queryStringParameters`: map(string)string - Query Strings parameters of the HTTP Request\n- `body`: string|byte() - Body of the HTTP Request, you will have to parse it in your handler to use it properly.\n- `headers`: map(string)string - HTTP Request Headers\n- `method`: string - HTTP method used\n- `isBase64Encoded`: boolean - Whether the request body is base64 encoded.\n\n#### Golang\n\nYou may take a look at [our scaleway-functions-go package](https://github.com/scaleway/scaleway-functions-go) (events and lambda) packages.\n\n### Context\n\nContext typings will be supported soon, you may already use it in functions, but every value be `defaults values` as our API does not support it right now.\n\n\n## Overview\nThis API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project.  By using the [OpenAPI-spec](https://www.openapis.org/) from a remote server, you can easily generate an API client.\n\n- API version: v1alpha2\n- Package version: 1.0.0\n- Build package: org.openapitools.codegen.languages.GoClientCodegen\n\n## Installation\n\nInstall the following dependencies:\n\n```shell\ngo get github.com/stretchr/testify/assert\ngo get golang.org/x/oauth2\ngo get golang.org/x/net/context\ngo get github.com/antihax/optional\n```\n\nPut the package under your project folder and add the following in import:\n\n```golang\nimport \"./openapi\"\n```\n\n## Documentation for API Endpoints\n\nAll URIs are relative to *https://api.scaleway.com*\n\nClass | Method | HTTP request | Description\n------------ | ------------- | ------------- | -------------\n*ContainersApi* | [**CreateContainer**](docs/ContainersApi.md#createcontainer) | **Post** /functions/v1alpha2/regions/{region}/containers | Create a new container\n*ContainersApi* | [**DeleteContainer**](docs/ContainersApi.md#deletecontainer) | **Delete** /functions/v1alpha2/regions/{region}/containers/{container_id} | Delete a container\n*ContainersApi* | [**GetContainer**](docs/ContainersApi.md#getcontainer) | **Get** /functions/v1alpha2/regions/{region}/containers/{container_id} | Get a container\n*ContainersApi* | [**ListContainers**](docs/ContainersApi.md#listcontainers) | **Get** /functions/v1alpha2/regions/{region}/containers | List all your containers\n*ContainersApi* | [**UpdateContainer**](docs/ContainersApi.md#updatecontainer) | **Patch** /functions/v1alpha2/regions/{region}/containers/{container_id} | Update an existing container\n*CronsApi* | [**CreateCron**](docs/CronsApi.md#createcron) | **Post** /functions/v1alpha2/regions/{region}/crons | Create a new cron\n*CronsApi* | [**DeleteCron**](docs/CronsApi.md#deletecron) | **Delete** /functions/v1alpha2/regions/{region}/crons/{cron_id} | Delete an existing cron\n*CronsApi* | [**GetCron**](docs/CronsApi.md#getcron) | **Get** /functions/v1alpha2/regions/{region}/crons/{cron_id} | Get a cron\n*CronsApi* | [**ListCrons**](docs/CronsApi.md#listcrons) | **Get** /functions/v1alpha2/regions/{region}/crons | List all your crons\n*CronsApi* | [**UpdateCron**](docs/CronsApi.md#updatecron) | **Patch** /functions/v1alpha2/regions/{region}/crons/{cron_id} | Update an existing cron\n*DefaultApi* | [**DeployContainer**](docs/DefaultApi.md#deploycontainer) | **Post** /functions/v1alpha2/regions/{region}/containers/{container_id}/deploy | \n*DefaultApi* | [**DeployFunction**](docs/DefaultApi.md#deployfunction) | **Post** /functions/v1alpha2/regions/{region}/functions/{function_id}/deploy | \n*DefaultApi* | [**GetFunctionDownloadURL**](docs/DefaultApi.md#getfunctiondownloadurl) | **Get** /functions/v1alpha2/regions/{region}/functions/{function_id}/download-url | \n*DefaultApi* | [**GetFunctionUploadURL**](docs/DefaultApi.md#getfunctionuploadurl) | **Get** /functions/v1alpha2/regions/{region}/functions/{function_id}/upload-url | \n*DefaultApi* | [**IssueJWT**](docs/DefaultApi.md#issuejwt) | **Get** /functions/v1alpha2/regions/{region}/jwt/issue | \n*FunctionsApi* | [**CreateFunction**](docs/FunctionsApi.md#createfunction) | **Post** /functions/v1alpha2/regions/{region}/functions | Create a new function\n*FunctionsApi* | [**DeleteFunction**](docs/FunctionsApi.md#deletefunction) | **Delete** /functions/v1alpha2/regions/{region}/functions/{function_id} | Delete a function\n*FunctionsApi* | [**GetFunction**](docs/FunctionsApi.md#getfunction) | **Get** /functions/v1alpha2/regions/{region}/functions/{function_id} | Get a function\n*FunctionsApi* | [**ListFunctionRuntimes**](docs/FunctionsApi.md#listfunctionruntimes) | **Get** /functions/v1alpha2/regions/{region}/runtimes | List function runtimes\n*FunctionsApi* | [**ListFunctions**](docs/FunctionsApi.md#listfunctions) | **Get** /functions/v1alpha2/regions/{region}/functions | List all your functions\n*FunctionsApi* | [**UpdateFunction**](docs/FunctionsApi.md#updatefunction) | **Patch** /functions/v1alpha2/regions/{region}/functions/{function_id} | Update an existing function\n*LogsApi* | [**ListLogs**](docs/LogsApi.md#listlogs) | **Get** /functions/v1alpha2/regions/{region}/logs | List your application logs\n*NamespacesApi* | [**CreateNamespace**](docs/NamespacesApi.md#createnamespace) | **Post** /functions/v1alpha2/regions/{region}/namespaces | Create a new namespace\n*NamespacesApi* | [**DeleteNamespace**](docs/NamespacesApi.md#deletenamespace) | **Delete** /functions/v1alpha2/regions/{region}/namespaces/{namespace_id} | Delete an existing namespace\n*NamespacesApi* | [**GetNamespace**](docs/NamespacesApi.md#getnamespace) | **Get** /functions/v1alpha2/regions/{region}/namespaces/{namespace_id} | Get a namespace\n*NamespacesApi* | [**ListNamespaces**](docs/NamespacesApi.md#listnamespaces) | **Get** /functions/v1alpha2/regions/{region}/namespaces | List all your namespaces\n*NamespacesApi* | [**UpdateNamespace**](docs/NamespacesApi.md#updatenamespace) | **Patch** /functions/v1alpha2/regions/{region}/namespaces/{namespace_id} | Update an existing namespace\n\n\n## Documentation For Models\n\n - [GoogleProtobufStruct](docs/GoogleProtobufStruct.md)\n - [GoogleProtobufValue](docs/GoogleProtobufValue.md)\n - [GoogleProtobufValueListValue](docs/GoogleProtobufValueListValue.md)\n - [GoogleProtobufValueStructValue](docs/GoogleProtobufValueStructValue.md)\n - [InlineObject](docs/InlineObject.md)\n - [InlineObject1](docs/InlineObject1.md)\n - [InlineObject2](docs/InlineObject2.md)\n - [InlineObject3](docs/InlineObject3.md)\n - [InlineObject4](docs/InlineObject4.md)\n - [InlineObject5](docs/InlineObject5.md)\n - [InlineObject6](docs/InlineObject6.md)\n - [InlineObject7](docs/InlineObject7.md)\n - [ScalewayFunctionsV1alpha2Container](docs/ScalewayFunctionsV1alpha2Container.md)\n - [ScalewayFunctionsV1alpha2ContainerPrivacy](docs/ScalewayFunctionsV1alpha2ContainerPrivacy.md)\n - [ScalewayFunctionsV1alpha2ContainerStatus](docs/ScalewayFunctionsV1alpha2ContainerStatus.md)\n - [ScalewayFunctionsV1alpha2Cron](docs/ScalewayFunctionsV1alpha2Cron.md)\n - [ScalewayFunctionsV1alpha2CronStatus](docs/ScalewayFunctionsV1alpha2CronStatus.md)\n - [ScalewayFunctionsV1alpha2DownloadUrl](docs/ScalewayFunctionsV1alpha2DownloadUrl.md)\n - [ScalewayFunctionsV1alpha2Function](docs/ScalewayFunctionsV1alpha2Function.md)\n - [ScalewayFunctionsV1alpha2FunctionPrivacy](docs/ScalewayFunctionsV1alpha2FunctionPrivacy.md)\n - [ScalewayFunctionsV1alpha2FunctionRuntime](docs/ScalewayFunctionsV1alpha2FunctionRuntime.md)\n - [ScalewayFunctionsV1alpha2FunctionStatus](docs/ScalewayFunctionsV1alpha2FunctionStatus.md)\n - [ScalewayFunctionsV1alpha2ListContainersRequestOrderBy](docs/ScalewayFunctionsV1alpha2ListContainersRequestOrderBy.md)\n - [ScalewayFunctionsV1alpha2ListContainersResponse](docs/ScalewayFunctionsV1alpha2ListContainersResponse.md)\n - [ScalewayFunctionsV1alpha2ListCronsRequestOrderBy](docs/ScalewayFunctionsV1alpha2ListCronsRequestOrderBy.md)\n - [ScalewayFunctionsV1alpha2ListCronsResponse](docs/ScalewayFunctionsV1alpha2ListCronsResponse.md)\n - [ScalewayFunctionsV1alpha2ListFunctionRuntimesResponse](docs/ScalewayFunctionsV1alpha2ListFunctionRuntimesResponse.md)\n - [ScalewayFunctionsV1alpha2ListFunctionsRequestOrderBy](docs/ScalewayFunctionsV1alpha2ListFunctionsRequestOrderBy.md)\n - [ScalewayFunctionsV1alpha2ListFunctionsResponse](docs/ScalewayFunctionsV1alpha2ListFunctionsResponse.md)\n - [ScalewayFunctionsV1alpha2ListLogsRequestOrderBy](docs/ScalewayFunctionsV1alpha2ListLogsRequestOrderBy.md)\n - [ScalewayFunctionsV1alpha2ListLogsResponse](docs/ScalewayFunctionsV1alpha2ListLogsResponse.md)\n - [ScalewayFunctionsV1alpha2ListNamespacesRequestOrderBy](docs/ScalewayFunctionsV1alpha2ListNamespacesRequestOrderBy.md)\n - [ScalewayFunctionsV1alpha2ListNamespacesResponse](docs/ScalewayFunctionsV1alpha2ListNamespacesResponse.md)\n - [ScalewayFunctionsV1alpha2Log](docs/ScalewayFunctionsV1alpha2Log.md)\n - [ScalewayFunctionsV1alpha2Namespace](docs/ScalewayFunctionsV1alpha2Namespace.md)\n - [ScalewayFunctionsV1alpha2NamespaceStatus](docs/ScalewayFunctionsV1alpha2NamespaceStatus.md)\n - [ScalewayFunctionsV1alpha2Token](docs/ScalewayFunctionsV1alpha2Token.md)\n - [ScalewayFunctionsV1alpha2UploadUrl](docs/ScalewayFunctionsV1alpha2UploadUrl.md)\n - [ScalewayStdMapStringStringValue](docs/ScalewayStdMapStringStringValue.md)\n\n\n## Documentation For Authorization\n\n\n\n## scaleway\n\n- **Type**: API key\n\nExample\n\n```golang\nauth := context.WithValue(context.Background(), sw.ContextAPIKey, sw.APIKey{\n    Key: \"APIKEY\",\n    Prefix: \"Bearer\", // Omit if not necessary.\n})\nr, err := client.Service.Operation(auth, args)\n```\n\n\n\n## Author\n\n\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frumpl%2Fgosc","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Frumpl%2Fgosc","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frumpl%2Fgosc/lists"}