Skip to navigation Skip to main content Skip to footer Scaleway DocsAsk our AI

Log in
Sign up

Foremost Links

API Documentation
Tutorials
Use cases
Troubleshooting Hub
Interactive Demos
FAQs
Changelog

Management & Governance

Account

Account

How to

Create an account

Verify your identity

Log in to the console

Change account ownership

Change the language

Switch from a personal to a corporate account

Change the color theme of the console

Configure support plans

Use multifactor authentication

Change a password

Recover a lost password

Open a support ticket

Manage my personal information (GDPR)

Download Scaleway contracts

Manage notifications

Use the search bar

Resolve abuse tickets and cases

Close an account

API/CLI

Account API Reference

Additional Content

Use case: informational website

Product availability overview

Scaleway network information

Subscribing to Scaleway status updates

Understanding support plans

Protecting yourself against phishing and fraud

Troubleshooting

Cost & Impact Management

Billing

How to

Add payment method

Set up billing notifications

Change billing information

Change payment method

Use the cost manager

Purchase a savings plan

Redeem a voucher

Use billing alerts

Download an invoice

API/CLI

Billing API Reference

Retrieve monthly consumption

Additional Content

Reading an invoice

Understanding savings plans

Troubleshooting

Environmental Footprint

How to

Use the Environmental Footprint dashboard

Track your monthly environmental footprint report

Additional Content

Calculation breakdown

Calculation reference values

Calculator product integration

Understanding your environmental footprint estimation

Bare Metal footprint calculation

Instances footprint calculation

Block Storage footprint calculation

Object Storage footprint calculation

Load Balancer footprint calculation

Kubernetes footprint calculation

Security & Identity

IAM

How to

Log in as a Member

Comply with security requirements as a Member

Create API keys

Manage API keys

Enforce security requirements for Members

Set up identity federation

Set up SSO with Authentik

Set up automatic user provisioning with SCIM

Set and manage credential maximum duration

Create an application

Manage applications

Create a policy

Manage policies

View event logs

View permission sets

Additional Content

Understanding Scaleway IAM

Users, groups and applications

Understanding IAM Policies

Understanding policy conditions

Permission sets

Reproducing roles and Project-scoped API keys with IAM

Auto-generated IAM resources

API/CLI

IAM API Reference

Using IAM API keys with Object Storage

Troubleshooting

Key Manager

How to

Create a Key Manager key

Retrieve the ID of a Key Manager key

Create and manage a Key Manager data encryption key

Rotate Key Manager keys

Disable Key Manager keys

Schedule Key Manager keys for deletion

Recover keys scheduled for deletion

Additional Content

Understanding security measures when using Key Manager

Understanding Key Manager

Understanding Key Manager cryptography

Differences between Key Manager and Secret Manager

API/CLI

Key Manager API Reference

Creating a data encryption key using the Scaleway API and the Scaleway CLI

Setting up and configuring Tink

Managing your Key Manager keys using Tink

Rotate keys using the Scaleway CLI and API

Encrypting and decrypting data with a Key Manager data encryption key

Encrypting and decrypting data streams with Streaming AEAD, Tink and Key Manager

Encrypting and decrypting data with an asymmetric key

Managing signatures using the Scaleway Go SDK and Key Manager

Organizations and Projects

How to

Manage Organization quotas

Set an Organization alias

Create a Project

Change a Project name

Generate an SSH key

Enforce multifactor authentication

Add resources to a Project

Delete a Project

Additional Content

Understanding Organization quotas

API/CLI

Managing Projects using Scaleway APIs

Secret Manager

How to

Manage a secret

Manage a version

Schedule a secret deletion

Schedule a version deletion

Recover secrets scheduled for deletion

Recover a version scheduled for deletion

Additional Content

Secret encryption with Scaleway's Secret Manager

Understanding secret types

Secret Manager capabilities and limits

API/CLI

Secret Manager API Reference

Deploying External Secrets on Kubernetes Kapsule

Creating a database credentials secret type

Products

AI

Generative APIs

How to

Query language models

Query reasoning models

Query vision models

Query embedding models

Query code models

Query audio models

Use structured outputs

Use function calling

API/CLI

Using Generative APIs

Using Models API

Using Embeddings API

Understanding errors

Additional Content

Supported models

Model lifecycle

Security and Reliability in Generative APIs

Adding AI to VS Code using Continue

Adding AI to IntelliJ IDEA using Continue

Adding AI to the Zed IDE

Integrating Generative APIs with n8n

Integrating Generative APIs with Openclaw

Integrating Generative APIs with Cursor

Integrating Generative APIs with OpenCode

Integrating Generative APIs with Claude Code

Integrating Generative APIs with Qwen Code

Integrating Generative APIs with popular AI tools

Troubleshooting

Managed Inference

How to

Import a custom model

Change the model of a deployment

Monitor a deployment

Configure autoscaling

Manage access to a deployment

Use your Managed Inference deployment with a Private Network

Delete a deployment

API/CLI

Managed Inference API Reference

Additional Content

Data, privacy, and security for Scaleway's AI services

OpenAI API compatibility

Supported models in Managed Inference

Support for function calling in Scaleway Managed Inference

Managed Inference model catalog

Bare Metal

Apple silicon

How to

Create a Mac mini

Access the remote desktop of a Mac mini

Connect to a Mac mini using SSH

Use Private Networks

Remove the public IP address

Install a package manager

Create a GitHub/GitLab runner

Update the OS of a Mac mini

Upgrade to a beta version of macOS

Set up a virtual machine (VM) with UTM

Test MDM workflows using a VM

Reboot a Mac mini

Shutdown a Mac mini

Reinstall a Mac mini

Adjust the available bandwidth

Manage your commitment plan

Delete a Mac mini

API/CLI

Apple silicon API Reference

Creating a server with kernel extensions enabled via API

Additional Content

Bare Metal shared responsibility model

Apple silicon datasheet

Scaleway Dev OS for Apple silicon

Troubleshooting

Dedibox

How to

Order a Dedibox

Install a Dedibox

Connect to your Dedibox

Order a failover IP

Configure a failover IP

Attach or detach a failover IP

Configure reverse DNS of a failover IP

Activate an IPv6 block

Modify Dedibox options

Use rescue mode

Reinstall a Dedibox

Terminate a Dedibox subscription

API/CLI

Dedibox API Reference

Additional Content

Bare Metal shared responsibility model

Dedibox and Scaleway account linking

Dedibox datasheet

Mounting filesystems in rescue mode

Elastic Metal

How to

Create a server

Install a server

Connect to your server

Adjust the available bandwidth

Configure custom disk partitioning

Order a flexible IP

Attach/detach a flexible IP

Configure a flexible IP (IPv4)

Configure a flexible IP (IPv6)

Configure a flexible IPv6 on a virtual machine

Configure reverse DNS of a flexible IP

Use Private Networks

Add a virtual MAC address

Create a virtual MAC group

Activate remote access

Send metrics & logs to Cockpit

View the event logs

Use rescue mode

Reboot a server

Reinstall a server

Shut down a server

Delete a server

Change the billing period

Get and use a loyalty reward

Run Kubernetes nodes on RISC-V

API/CLI

Elastic Metal API Reference

Creating and managing Elastic Metal servers with the CLI

Managing Elastic Metal servers with the API

Additional Content

Bare Metal shared responsibility model

Elastic Metal datasheet

Elastic Metal Server stock levels explained

Understanding Elastic Metal networking

Elastic Metal RV1 guidelines

End of VMware ESXi support on Elastic Metal and Dedibox servers

Troubleshooting

Compute

CPU Instances

How to

Create an Instance

Manage Instance storage

Connect to an Instance

Use flexible IPs

Migrate Local Storage volumes to Block Storage

Use Security Groups

Use Private Networks

Configure reverse DNS

Send emails from your Instance

Enable OpenSSH server on Windows

Use placement groups

Create an image

Create an image from a snapshot

Resize Instances

Migrate Instances

Use standby mode

Protect an Instance

Power off an Instance

Use the serial console

Delete an Instance

API/CLI

Instances API Reference

Scaleway CLI Cheatsheet

Creating and Managing Instances

Creating backups

Changing the commercial type of an Instance

Using the import/export feature (API)

Managing Instance snapshots with the CLI (v2)

Using cloud-init

Using placement groups

Additional Content

Choosing an Instance type

Choosing between shared or dedicated CPUs

Instances datasheet

Instances Shared Responsibility Model

Instances internet and Block Storage bandwidth overview

The right Instance for development purposes

The right Instance for production purposes

The right Instance for specialized purposes

Instance OS images and InstantApps

Understanding the differences between ARM and x86 Instances

Moving Instances between Availability Zones and Projects

Understanding QEMU Guest Agent

Understanding automatic network hot-reconfiguration

Understanding Instance pricing

Identifying devices of an Instance

Migrating VMware virtual machines to Scaleway Instances

Preventing outgoing DDOS

Configuring Instances manually on a Private Network

Using tags to add Instance-specific SSH keys

Compatibility between Scaleway OS Images and Flexible IPs

Enabling DHCP network configuration for Windows Server 2022 Instances

Historical Instances offerings

Troubleshooting

GPU Instances

How to

Create and manage a GPU Instance

Use Docker on your GPU Instance

Use NVIDIA MIG technology on GPU Instances

Use NVIDIA MIG technology with Kubernetes

Use the scratch storage on H100 GPU Instances

Use the preinstalled environment

Use pipenv to create virtual environments

API/CLI

Instances API Reference

Additional Content

Choosing the right GPU Instance type

Blackwell vs Hopper - Choosing the right NVIDIA GPU architecture

Instances Shared Responsibility Model

GPU Instances internet and Block Storage bandwidth overview

Migrating from H100-2-80G to H100-SXM-2-80G

GPU time-slicing with Kubernetes

Docker AI images

Understanding NVIDIA GPU Cloud (NGC)

Understanding NVIDIA NeMo (Neural Models)

Understanding the NVIDIA TAO toolkit

Understanding NVIDIA FP4 format

Understanding NVIDIA FP8 format

Understanding NVIDIA NVLink

Troubleshooting

Containers

Container Registry

How to

Create a namespace

Connect the Docker CLI

Display image versions

Manage image privacy settings

Manage namespace privacy policies

Delete an image

Delete a namespace

API/CLI

Container Registry API Reference

Troubleshooting

Kubernetes

How to

Create a Kapsule cluster

Manage a Kapsule cluster

Create a Kosmos cluster

Manage a Kosmos cluster

Manage allowed IPs

Connect to a cluster with kubectl

Connect to a cluster within a Private Network

Manage Kapsule node pools

Deploy an image from Container Registry

Deploy an ingress controller

Enable the Easy Deploy feature

Monitor a Kapsule cluster with Cockpit

Monitor a cluster's data plane with Cockpit

Access the Kubernetes audit logs

Access the Kubernetes dashboard

Upgrade the Kubernetes version on a Kapsule cluster

Use the NVIDIA GPU operator on Kapsule and Kosmos with GPU Instances

Use the scratch storage on H100 GPU Instances with Kapsule

Deploy x86 and ARM images in Kubernetes

Recover ETCD database space for a cluster

How to use SFS with Kubernetes Kapsule

Enable or disable SSH

Delete a cluster

API/CLI

Kubernetes API Reference

Creating and managing a Kubernetes Kapsule

Monitoring clusters

Managing storage

Deploying External Secrets on Kubernetes Kapsule

Changing the control plane offer

Additional Content

Introduction to Kubernetes

Kubernetes Cheatsheet

Kubernetes control plane offers overview

Understanding differences between the Kapsule and Kosmos

Managed Kubernetes service definition

Kubernetes decision tree

Kubernetes version support policy

Securing a cluster with Private Networks

Ensuring resiliency with Multi-AZ clusters

Exposing Kubernetes services to the internet

Setting IAM permissions and implementing RBAC on a cluster

Configuring Kubernetes security groups

Modifying kernel parameters in a Kubernetes cluster using a DaemonSet

Creating and configuring a Load Balancer service

Using a Load Balancer with Ingress

Managing Load Balancer IPs

Using Load Balancer annotations

Using the Kapsule autoheal feature

Wildcard DNS routing

Migrate end-of-life pools to newer Instances

Troubleshooting

Databases

Managed Databases for PostgreSQL and MySQL

How to

Create a Database Instance

Connect to a Database Instance

Create a database

Manage snapshots

Manage Read Replicas

Clone a Database Instance

Manage allowed IPs

Configure advanced settings

Renew a TLS certificate

Monitor Database Instances with Cockpit

Upgrade Database Instance engine versions

Apply scheduled maintenance

Remove a public endpoint

Delete a database

Delete a Database Instance

Additional Content

Security and Reliability

PostgreSQL extensions reference

Migrating to Scaleway Managed Databases

PostgreSQL version updates

Encryption at rest performance benchmark

Understanding the autohealing feature

API/CLI

Managed Database for PostgreSQL and MySQL API Reference

Setting up encryption at rest

Setting up and using the pgaudit extension

Setting up and using the pg_cron extension

Verifying Servers' Certificate Authority on PostgreSQL

Migrating Database Instance endpoints via the Scaleway CLI

Importing data into Managed PostgreSQL Databases

Setting up logical replication as a subscriber

Setting up logical replication as a publisher

Connecting Managed Databases to Kubernetes clusters

Troubleshooting

Managed Databases for Redis™

How to

Create a Redis™ Database Instance

Connect to a Redis™ Database Instance

Manage allowed IPs

Scale up a Redis™ Database Instance

Configure advanced settings

Monitor Database Instances with Cockpit

Delete a Redis™ Database Instance

API/CLI

Managed Database for Redis™ API Reference

Managing username and password

Using Publish/Subscribe messaging

Upgrade your Redis™ version

Additional Content

Understanding default user permissions

Ensuring data persistence

Troubleshooting

Managed MongoDB®

How to

Create a Database Instance

Connect a Database Instance to a Private Network

Connect to a Database Instance

Manage snapshots

Increase the storage size

Delete a Database Instance

Additional Content

Migrating to Managed MongoDB®

API/CLI

Back up and restore MongoDB® Databases

Migrating data with mongosync

Cloud Essentials for OpenSearch

How to

Create a deployment

Connect to a deployment

Manage a deployment

Manage the users of a deployment

Use Private Networks

Delete a deployment

Additional Content

Choosing between shared and dedicated resources

Serverless SQL

How to

Create a Serverless SQL Database

Connect to a Serverless SQL Database

Add users to a Serverless SQL Database

Manage user permissions for Serverless SQL Databases

Monitor a Serverless SQL Database

Use Row-Level Security on a database

Edit a Serverless SQL Database's autoscaling

Manage backups for Serverless SQL Databases

Delete a Serverless SQL Database

API/CLI

Serverless SQL Database API Reference

Importing data into Serverless SQL Databases

Securing connections using SSL/TLS

Using Row-Level Security with PostgREST

Additional Content

Known differences between Serverless SQL Databases and PostgreSQL

Serverless SQL Databases overview

Supported PostgreSQL extensions

Planned maintenance

Troubleshooting

Data & Analytics

Data Warehouse for ClickHouse®

How to

Create a deployment

Manage and delete a deployment

Connect to a deployment

Manage databases in a deployment

Manage users in a deployment

Connect a deployment with BI tools

Use Private Networks

Monitor a deployment

Import data into a deployment

Edit the autoscaling of a deployment

Manage the storage policy of a deployment

API/CLI

Using a Public Gateway to connect to a deployment in a Private Network

Additional content

Example datasets

Features and limitations

Data Lab for Apache Spark™

How to

Create a Data Lab cluster

Access the notebook

Access the Spark™ UI

Use a cluster with Private Networks

Manage and delete a cluster

Troubleshooting

Clusters for Apache Kafka®

How to

Create a cluster

Connect to a cluster

Manage a cluster

Delete a cluster

API/CLI

Clusters for Apache Kafka® API Reference

NATS

How to

Create a NATS account

Create NATS credentials

Manage NATS credentials

Monitor NATS with Cockpit

Delete a NATS account

API/CLI

NATS API Reference

Using the NATS CLI

Additional Content

Troubleshooting

Developer Tools

Scaleway CLI

Additional Content

Scaleway CLI reference

Console CLI keyboard shortcuts

Environment variables

Scaleway Configuration file

How To

Automate resources management with the CLI and Jobs

Scaleway SDKs

Python SDK quickstart

Go SDK quickstart

JavaScript SDK quickstart

Additional Content

Environment variables

Scaleway Configuration file

Terraform

Additional Content

Environment variables

Scaleway Configuration file

Domains & Web Hosting

Domains and DNS

How to

Register a domain name

Transfer an external domain

Configure autorenew

Use the Domains and DNS trade feature

Lock an internal domain

Unlock an internal domain

Manage name servers for an internal domain

Configure DNSSEC for an internal domain

Configure DNS zones

Test DNS zones with dig

Manage DNS records

Add an external domain

Manage an external domain

Delete an external domain

API/CLI

Domains and DNS API Reference

Additional Content

Domain registration requirements

Understanding Domains and DNS

Understanding DNS record types

Troubleshooting

Transactional Email

How to

Configure your domain with Transactional Email

Manage Transactional Email plans

Autoconfigure a Scaleway domain with Transactional Email

Authenticate your domain

Set up BIMI for transactional emails

Manage your email activity

Monitor Transactional Email with Cockpit

Generate API keys for API and SMTP sending with IAM

Create and manage an email webhook

Manage blocklists

Delete your domain

API/CLI

Transactional Email API Reference

Sending an email using the Transactional Email API

Setting up and using TEM webhooks with Topics and Events

Additional Content

Transactional Email capabilities and limits

Understanding DMARC configuration

Protecting your domain's reputation with progressive emailing

Understanding your reputation score with Transactional Email

Setting up SMTP

Understanding managed dedicated IPs

Understanding webhook event payloads

Troubleshooting

Web Hosting

How to

Order a Web Hosting plan

Configure DNS for Web Hosting

Manage a Web Hosting with cPanel

Manage a Web Hosting with WordPress

Manage a Web Hosting plan

Manage FTP accounts

Manage databases

Allow remote access to Web Hosting databases

Manage email accounts

Order a dedicated IP for Web Hosting

Protect a Web Hosting plan

Terminate a Web Hosting plan

Migrate an Online.net/Dedibox web hosting plan to Scaleway

API/CLI

Web Hosting API Reference

Additional Content

cPanel additional content

PHP versions on Scaleway Web Hosting platforms

Web Hosting Classic migration - Technical information

Understanding cPanel

Understanding security measures on a shared hosting

Troubleshooting

Integration Services

IoT Hub

How to

Enable or disable a Hub

Provide your own Certificate Authority

Provide your own device certificate

Renew the certificate of a device

Connect to the default MQTT network

Connect to the default Websocket network

Use the MQTT Webclient

Set up and use a REST network

Set up and use a Sigfox network

Simulate events

Understand event messages

Triggering functions from IoT Hub messages

Enable auto-provisioning

Change the product plan

Delete a Device

API/CLI

IoT Hub API Reference

Getting started with the IoT Hub CLI

Getting started with the IoT Hub API

Configuring IoT Hub routes

Discovering IoT Hub Database Route Tips and Tricks

Migrating from the IoT API v1beta1

Additional Content

Understanding Hubs

Understanding Devices

Understanding Networks

Understanding Routes

Updating your Endpoint's Certificate Authority

Topics and Events

How to

Create credentials

Manage credentials

Create and manage topics

Create and manage subscriptions

Monitor Topics and Events with Cockpit

API/CLI

Topics and Events API Reference

Connecting Topics and Events to the AWS-CLI

Using Topics and Events with the AWS-CLI

Using Go, Python or Node.js with Topics and Events

Additional Content

Topics and Events overview

Topics and Events - supported actions

Verifying webhook signatures

Troubleshooting

Queues

How to

Create credentials

Manage credentials

Create and manage queues

Monitor Queues with Cockpit

API/CLI

Queues API Reference

Connecting Queues to the AWS-CLI

Using Queues with the AWS-CLI

Using Go, Python or Node.js with Queues

Additional Content

Queues overview

Queues - supported actions

Troubleshooting

Monitoring

Audit Trail

How to

Configure the Audit Trail permission set

Use Audit Trail

Create and manage Audit Trail exports

API/CLI

Audit Trail API Reference

Additional Content

Audit Trail product integration

IAM authentication events in Audit Trail

Supported endpoints for Audit Trail

Troubleshooting

Cockpit

How to

Access Grafana and preconfigured dashboards

Create a Cockpit token

Create a custom data source

Delete a custom data source

Change data sources retention period

Send metrics to Cockpit using Grafana Alloy

Send logs from your Kubernetes cluster to Cockpit

Send metrics from your Kubernetes cluster to Cockpit

Create and push and traces to your Cockpit

Configure the alert manager

Activate Scaleway preconfigured alerts

Configure alerts for Scaleway resources

Manage data exports

Use IAM authentication for Cockpit with Terraform/OpenTofu

API/CLI

Cockpit API Reference

Retrieving logs programmatically using LogCLI

Additional Content

Understanding and managing Cockpit ingestion to reduce costs

Cockpit capabilities and limits

Cockpit pricing information

Cockpit supported API endpoints for data source management

Cockpit product integration

Troubleshooting

Network

Edge Services

How to

Subscribe to Edge Services

Create an Object Storage pipeline

Create a Load Balancer pipeline

Configure a custom domain

Configure a cache

Monitor with Cockpit

Delete an Edge Services pipeline

Terminate an Edge Services subscription

Additional content

SSL/TLS certificates for Edge Services

CNAME records for Edge Services

Understanding WAF

Understanding pricing

Troubleshooting

InterLink

How to

Create an InterLink

Complete hosted InterLink provisioning

Configure an InterLink

Create a routing policy

Delete an InterLink

API/CLI

InterLink API Reference

Additional Content

InterLink overview

InterLink provisioning

Configuring an InterLink

InterLink statuses

Using BGP communities

IPAM

How to

List your private IP addresses

Manage your private IP addresses

Reserve an IP address

API/CLI

IPAM API Reference

Set a reverse IPv6 DNS record

Additional Content

Public connectivity: best practices

IPV6 and the Scaleway ecosystem

Understanding billing for IP addresses

Troubleshooting

Load Balancers

How to

Create a Load Balancer

Create frontends and backends

Manage frontends and backends

Add an SSL/TLS certificate

Create and manage ACLs

Create and manage routes

Use a Load Balancer with a Private Network

Set up an Edge Services pipeline

Set up a customized error page

Create and manage flexible IPs

Resize a Load Balancer

Monitor your Load Balancer with Scaleway Cockpit

Delete a Load Balancer

API/CLI

Load Balancer API Reference

Setting up SSL offloading

Configuring balancing rules

Additional Content

Configuring frontends

Configuring backends

Configuring health checks

Setting up SSL bridging, offloading or passthrough

Setting up your Load Balancer for HTTP/2 or HTTP/3

Understanding ACLs

Kubernetes Load Balancers

Public vs private Load Balancers

Migrating from AWS ELB

Deprecation of SNI routes with HTTP backends

Troubleshooting

Public Gateways

How to

Create a Public Gateway

Configure a Public Gateway

Upgrade a Public Gateway

Use SSH bastion

Use flexible IPs

Delete a Public Gateway

API/CLI

Public Gateway API Reference

Additional Content

Understanding Public Gateways

Understanding v2

Troubleshooting

Site-to-Site VPN

API/CLI

Site-to-Site VPN API Reference

Additional Content

Understanding Site-to-Site VPN

Site-to-Site VPN Security proposals

Site-to-Site VPN Statuses

VPC

How to

Create and manage a VPC

Create a Private Network

Activate DHCP on a legacy Private Network

Attach resources to a Private Network

Manage routing on a VPC

Delete a Private Network

API/CLI

VPC API Reference

Additional Content

Understanding routing

Understanding DNS

Understanding NACLs

Getting the most from Private Networks

VPC use case 1: basic infrastructure

Troubleshooting

Serverless

Containers

How to

Create, manage, and delete a namespace

Deploy a container

Manage a container

Build and push a container image

Add a custom domain to a container

Modify container privacy

Manage authentication for private containers

Migrate from legacy JWT to IAM authentication

Secure a container

Use Private Networks

Test a container

Monitor container logs and metrics

Add a trigger to a container

Configure alerts for a container

Delete a container

API/CLI

Containers API Reference

Create and deploy a container with the Scaleway API

Create and deploy a container with the Scaleway CLI

Migrate images to the Scaleway Registry

Additional Content

Serverless overview

Migrating to Serverless Containers

Containers and Private Networks integration

Containers limitations

Methods to deploy Serverless Containers

Containers use cases

Considerations to configure event retention for Queues trigger inputs

Containers concurrency

Containers autoscaling

Containers billing

Containers port parameter

Containers sandbox

Differences between Jobs, Functions and Containers

Cron schedules reference

DNS query rate limiting

Troubleshooting

Functions

How to

Create, manage, and delete a namespace

Create a function

Test a function

Package function in a zip file

Manage a function

Add a trigger to a function

Add a custom domain name to a function

Manage authentication for private functions

Migrate from legacy JWT to IAM authentication

Secure a function

Use Private Networks

Monitor function logs and metrics

Configure alerts for a function

Delete a function

Migrate Functions to Containers

API/CLI

Functions API Reference

Create and deploy a function with the Scaleway API

Create and deploy a function with the Scaleway CLI

Additional Content

Serverless overview

Functions runtimes

Functions and Private Networks integration

Functions limitations

Methods to deploy Serverless Functions

Functions local testing

Functions use cases

Functions handlers

Functions autoscaling

Functions sandbox

Considerations to configure event retention for Queues trigger inputs

Serverless Functions billing

Differences between Jobs, Functions and Containers

Available memory and CPU tiers

Cron schedules reference

DNS query rate limiting

Troubleshooting

Jobs

How to

Build and push a container image

Automate resources management with Jobs

Manage the scheduling of a job

Execute complex startup commands

Reference secrets in a job

Configure alerts for a job

API/CLI

Jobs API Reference

Migrate images to the Scaleway Registry

Additional Content

Serverless overview

Jobs limitations

Differences between Jobs, Functions and Containers

Methods to deploy Serverless Jobs

Cron schedules reference

v1alpha1 to v1alpha2

Troubleshooting

Quantum

Quantum Computing

How to

Use Quandela QPUs & emulators

Use Pasqal QPUs & emulators

Use IQM QPUs & emulators

Use AQT QPUs & emulators

Use remote CUDA-Q emulators

Use remote Aer emulators

Use remote Qsim emulators

Run Quantum Machine Learning with Pennylane

API/CLI

QaaS API Reference

Additional Content

Quantum Computing Information

SDK & backend compatibility

AQT QPUs Information

IQM QPUs Information

Pasqal QPUs Information

Quandela QPUs Information

Storage

Block Storage

How to

Create a volume

Attach a volume

Host healthcare data (HDS)

Increase the volume size

Create a snapshot of a Block Storage volume

Create a Block Storage volume from a snapshot

Identify the type of a volume or a snapshot

Detach a volume

Unmount a volume

Delete a snapshot

Delete a volume

API/CLI

Block Storage API Reference

Using Block Storage with the Scaleway CLI

Increasing the size of a partition

Increasing volume size via the API

Additional Content

Storage shared responsibility model

Differences between Block Storage volumes

Block Storage and Instances bandwidth overview

File Storage

How to

Create a file system

Attach a file system

Mount a file system to an Instance

Manage and delete a file system

Resize a file system

Unmount a file system from an Instance

Detach a file system

API/CLI

Using File Storage with the Scaleway CLI

Additional content

File Storage limitations

Local Storage

How to

Create a volume

Attach a volume

Create a snapshot of a Local Storage volume

Create a Local Storage volume from a snapshot

Detach a volume

Delete a snapshot

Delete a volume

Object Storage

How to

Create a bucket

Upload files into a bucket

Edit the storage class

Restore an object from Glacier class

Download files from a bucket

Manage object visibility

Access objects via HTTPS

Use bucket versioning

Create and manage bucket policies

Manage lifecycle rules

Host healthcare data (HDS)

View and abort incomplete multipart uploads

Monitor your consumption

Set up a static website

Use Object Storage with Private Networks

Set up an Edge Services pipeline

Delete an object

Delete a bucket

API/CLI

Using the Object Storage API

Understanding common operations

Understanding bucket operations

Understanding object operations

Using the AWS-CLI

Installing MinIO Client

Installing rclone

Managing the lifecycle of objects

Managing Object Storage using using CLI tools

Managing multipart uploads

Setting CORS rules

Bucket policies overview

Creating and applying bucket policies

Combining IAM and bucket policies for granular access

Managing bucket permissions for IP addresses

Setting up object lock

Hosting static websites on a bucket

Generating an AWSv4 authentication signature

Migrating data from one bucket to another

Adding objects to a bucket with POST

Additional Content

Storage shared responsibility model

Optimize your Object Storage performance

Equivalence between Object Storage actions and IAM permissions

Supported checksums

Logs and metrics collected by Cockpit

Troubleshooting

Dedibox

Dedibox Console

Classic Hosting

How to

Create an FTP account

Change the password of an FTP account

Connect via FTP

Delete an FTP account

Create an email account

Change the password of an email account

Delete an email account

Check the emails

Configure Outlook

Create an alias

Encrypt your emails with PGP using the Scaleway webmail

Retrieve the header of an email

Manage email filters

Solve email account connection problems

Configure an htaccess file

Create a MySQL database

Change the password of a MySQL database

Delete a MySQL database

Manage a MySQL database with phpMyAdmin

Create a PostgreSQL database

Change the password of a PostgreSQL database

Delete a PostgreSQL database

Manage a PostgreSQL database with Adminer

Create an email redirection

Delete an email redirection

Create an email transfer

Delete an email transfer

Access the logcenter

Access the website statistics

Create a subdomain

Delete a subdomain

Configure the backup option

Terminate an Online Web Hosting plan

cPanel Hosting

Additional Content

Dedibox Account

How To

Create a Dedibox account

Add a payment method

Enable multifactor authentication

Disable multifactor authentication

Update your password

Update your account email

Upload an SSH key

Outsource a Dedibox

Oursource a failover IP

Accept outsourcing

Revoke outsourcing

Contact the Support team

Report an incident

Manage privacy data settings

Recover the password in case of a lost email account

Dedibox Servers

Hardware

How to

Configure hardware RAID from the console

Configure a DELL PERC H200 RAID controller

Configure a DELL PERC H310/H700/H710/H730-P/LSI9361 RAID controller

Configure an HP Smart Array (P222 / P410 / P420) RAID controller

Configure the DELL PERC H200 RAID controller from the KVM

Configure the DELL PERC H310 RAID controller from the KVM

Configure the HP Smart Array P410 RAID controller from the KVM

Configure the HP Smart Array P420 RAID controller from the KVM

Additional Content

Server comparison table

Troubleshooting

Dedicated Server

How to

Install a server

Connect to a server

Get started with your server

Change the root password

Manage packages

Change the language of a Windows Server

Monitor a server

Back up a server

Migrate a server

Restart a server

Use rescue mode

Rescue your data

Use IPMI on a server

Use the serial console

Terminate a server

Give IAM Members access to the Dedibox console

Additional Content

Dedibox server datasheet

Basic Linux commands

Dedibox VPS

How to

Create a Dedibox VPS

Connect to a Dedibox VPS

Manage a Dedibox VPS

Reinstall a Dedibox VPS

Delete a Dedibox VPS

KVM-over-IP

How to

Understanding the Baseboard Management Controller (BMC)

Use DELL iDRAC 6

Use DELL iDRAC 7

Use DELL iDRAC 8

Use DELL iDRAC 9

Use the Supermicro KVM

Use the Quanta Computer KVM

Use the QuantaPlex KVM

Disable boot errors using iDRAC

Troubleshooting

Dedibox Network

Domains

How to

Buy a domain name

Renew a domain name

Transfer a domain name

Change the ownership of a domain

File contact information

Validate WAPS information

Manage DNS servers

Manage DNS zones

DNS

How to

Configure the reverse DNS

Add a DNS delegation

Configure secondary DNS

Failover IP

How to

Order a failover IP

Assign a failover IP

Configure the reverse DNS

Configure a failover IP on CentOS

Configure a failover IP on Debian/Ubuntu

Configure a failover IP on FreeBSD

Configure a failover IP on Windows Server

Create a virtual MAC address

Configure a multi-IP virtual MAC address group

Configure the network of a virtual machine

IPv6

How to

Request an IPv6 prefix

Create an IPv6 subnets

Enable IPv6 SLAAC

Configure IPv6 on Linux

Configure IPv6 on Windows

Resolve connectivity issues

Network

How to

Configure Network with Netplan on Ubuntu

Subscribe to JMRP

Additional Content

Anti-DDoS Solutions

Troubleshooting

RPN

How to

Configure jumboframes

Configure the RPNv1

Configure the RPNv2

Use the RPN VPN

Configure the RPNv1 gateway

Find the RPNv1 gateway

Connect to an RPN SAN

Mount an RPN SAN on Linux

Configure RPN SAN on ESXi 5/6

Configure RPN SAN on ESXi 7

Configure RPN SAN on Proxmox

Connect Windows Server to an RPN SAN

Additional Content

Private Networks overview

Additional Services

Partners

Partner Space

How to

Edit client information

Track client consumption

Lock a client's Organization

Unlock a client's Organization

Grant access to the Partner Space

Quick Links

Scaleway Learning
Docs Github

Need help?

Ask us anything about Scaleway products

API Documentation
Scaleway console
Dedibox console
Scaleway Learning
Scaleway.com
Pricing
Blog
Careers

© 2023-2026 – Scaleway

No Results