Affordable servers with the best price-performance ratio on the market

Start

Perfect balance of processing power, memory and storage

The high performance backbone of your mission-critical infrastructure

Core

For mission-critical data, fast storage, backup and streaming

Store

Dedicated GPU power with reliable performance and stability

Host your Hardware in our secured French datacenters

Dedirack

60 locations worldwide, starting at €4,99/month

Dedibox VPS

Dedibox - dedicated servers

Fully dedicated bare metal servers with native cloud integration, at the best price

Aluminium

Powerful, balanced and reliable servers for production-grade applications

Beryllium

Powerful dedicated server designed to handle high-workload applications

Iridium

Designed with huge local storage to keep, back up, and protect your data

Lithium

Power and stability of dedicated GPU hardware integrated into the Scaleway ecosystem

Titanium

Elastic Metal - bare metal cloud

Enjoy the Mac mini experience with great simplicity

Mac mini M1

Perform your daily tasks with speed and efficiency

Mac mini M2

Realize your most ambitious projects thanks to a new level of power

Mac mini M2 Pro

Apple

Dedibox and Bare Metal

Dedicated vCPU for the most demanding workloads (x86)

Production-Optimized

Secure, scalable VMs, equipped for high memory and compute demands (x86)

Workload-Optimized

Highly reliable and priced affordably Instances with shared vCPUs (x86 and ARM)

Cost-Optimized

A tiny instance to test and host your personal projects (x86)

Learning

Virtual Instances

Maximize your AI infrastructures with a versatile Instance

L4 GPU Instance

Universal Instance, faster than L4 and cheaper than H100 PCIe

L40S GPU Instance

Accelerate your model training with the most high-end AI chip

H100 PCIe GPU Instance

Dedicated NVIDIA® RTX 3070 with the best price/performance ratio

GPU 3070 Instances

Dedicated Tesla P100s for all your Machine Learning & Artificial Intelligence needs.

Render GPU Instances

Experience an easy way to run your code on the cloud

Serverless Functions

Easily run containers on the cloud with a single command

Serverless Containers

Serverless Jobs

Serverless

Kubernetes exclusively for Scaleway products and resources

Kubernetes Kapsule

Multi-cloud Kubernetes for Scaleway and external providers resources

Kubernetes Kosmos

Container Registry

Containers

Compute

Build the next Foundation Model with one of the fastest and most energy-efficient supercomputers in the world

Custom-built Clusters

Rent a GPU-cluster from 32 to more than a thousand GPUs to speed up distributed training

On Demand Cluster

Clusters

Deploy AI models in a dedicated inference infrastructure. Get tailored security and predictable throughput

Managed Inference

Consume AI models instantly via a simple API call. All hosted in Europe

Generative APIs

Model-as-a-service

Accelerate the next generation of AI-enabled applications with the universal L40S GPU Instance, faster than L4 and cheaper than H100 PCIe

Maximize your AI infrastructure's potential with a versatile and cost-effective GPU Instance

Dedicated Tesla P100s for all your Machine Learning & Artificial Intelligence needs

Render GPU Instance

GPU Instances

Amazon S3-compatible and Multi-AZ resilient object storage service. Ensuring high availability for your data

Object Storage

Cold Storage class to secure long-term object storage. Ideal for deep archived data.

Scaleway Glacier

Flexible and reliable storage for demanding workloads

Block Storage

Storage

Secure your cloud resources with ease on a resilient regional network

Virtual Private Cloud

 A single and secure entrance to your infrastructure

Public Gateway

Improve the performance of your services as you grow

Load Balancer

Buy domain names and manage DNS. Find your favourite extensions at a fair price

Domains and DNS

Centralize and simplify your Scaleway IP address management

IPAM (IP Address Manager)

Expose your HTTP services to the internet with security, reliability, and efficiency by design.

Edge Services

Network

New generation of Relational Databases designed to scale on-demand

Managed Database for PostgreSQL & MySQL

Accelerate your web application with powerful caching of Memory Databases

Managed Database for Redis™

Drive your own document-oriented database. Let us managed the engine

Managed MongoDB®

Go serverless with fully managed database

Serverless SQL Database

Send messages and events without having to manage your message broker

Messaging and Queuing

Speed up data processing over very large volumes of data with an Apache Spark™ managed solution.

Distributed Data Lab

Data

Hosting for individuals, professionals, and everyone in between.

Web Hosting

Ship your applications only in a few clicks.

Web Platform

Instant delivery of your transactional emails

Transactional Email

Monitor infrastructures in minutes with a fully managed observability solution

Cockpit

A purpose-built bridge between connected hardware and cloud.

IoT Hub

Business Applications

The easiest way to safely collaborate in the cloud

Identity and Access Management (IAM)

Protect your sensitive data across your cloud infrastructure

Secret Manager

Easily track your consumption in an all-in-one tool

Cost Manager

Accurately track your environmental impact and make informed choices

Environmental Footprint Calculator

Security & Organization

Scaleway API

Deploy and manage your infrastructure directly from the command line

Securely and efficiently provision and manage Infrastructure as Code with Terraform

Terraform

Developer Tools

Data & Tools

Artificial Intelligence

Public Sector

Gaming

Media and Entertainment

Retail and E-commerce

Startup Program

Financial Services

Industrial

Industries

Cloud Storage Solutions

Kubernetes Solutions

Serverless Applications

Use Cases

Managed Web Hosting

Dedicated Web Hosting

Solutions

All products

Product updates

Betas

Changelog

Blog

Ecosystem

Slack Community

Feature Requests

Scaleway Learning

Community

Events

Marketplace

Careers

About us

Labs

Customer Testimonials

Company

Resources

Pricing

Docs

Contact

Kubernetes has become a game-changing technology for container orchestration, and the vibrant open-source community has been a driving force behind its success. The curated selection of Kubernetes tooling presented here shows the breadth and depth of the ecosystem that has grown around Kubernetes.

From automation and monitoring to networking and security, these tools provide a solid foundation for managing containerized applications. The ongoing development of new open-source projects within the Kubernetes community is a testament to its vitality and innovation.

If you have spend countless hours working with Kubernetes, you understand the unique challenges of managing a complex infrastructure at scale. While Kubernetes is an incredibly powerful platform for deploying and managing containerized applications, it can also transform into a complex mess. So let's discover new tools to orchestrate your infrastructure!

![](https://www-uploads.scaleway.com/Kubernetes_tooling_Scaleway_5cef6c71ac.gif)

## Deployment and configuration management 

### Kustomize
[Kustomize](https://kustomize.io/) is a tool that lets you customize Kubernetes resources by applying patches to base configurations. It provides a simple and declarative way to manage your Kubernetes configurations, allowing you to manage different environments and configurations with ease. 
👉 [Kustomize’s GitHub](https://github.com/kubernetes-sigs/kustomize) 

### Jsonnet
[Jsonnet](https://jsonnet.org) is a configuration language that can be used to generate Kubernetes manifests. It provides a clear way to define Kubernetes resources using a flexible and expressive syntax, which can be used to manage complex and large configurations. 
👉 [Jsonnet's GitHub](https://github.com/google/jsonnet)

### Skaffold
[Skaffold](https://skaffold.dev/) is a command-line tool that streamlines the development workflow for Kubernetes applications. It supports many popular programming languages and development tools, and can be integrated with CI/CD pipelines.
👉 [Skaffold's GitHub](https://github.com/GoogleContainerTools/skaffold)

### Helm
Helm is the well-known package manager for Kubernetes that simplifies the installation and management of complex applications. It provides a templating system that allows you to define your applications as charts, which can be effortlessly installed and configured on your Kubernetes cluster. 
You can also read more on our [blog post about Helm](https://www.scaleway.com/en/blog/helm-guide/).
👉 [Helm's GitHub](https://github.com/helm/helm) 

### Kubeconfig-generator
[Kubeconfig-generator](https://github.com/kubernetes/kubeconfig-generator) is a tool for generating Kubernetes configuration files (kubeconfig) for multiple clusters and users. With Kubeconfig-generator, you can simplify the process of managing multiple clusters and users by generating configuration files automatically. It supports many popular Kubernetes distributions and can be integrated with CI/CD pipelines. 
👉 [Kubeconfig-generator's Github](https://github.com/kubernetes/kubeconfig-generator) 



## Monitoring and observability 

### Prometheus
[Prometheus](https://prometheus.io) is a monitoring tool that collects metrics from Kubernetes resources and stores them in a time-series database—it is a powerful way to monitor the health and performance of your Kubernetes cluster and applications. 
👉 [Prometheus's GitHub](https://github.com/prometheus/prometheus) 

### Thanos
[Thanos](https://thanos.io) is a tool that extends Prometheus by adding long-term storage, global querying, and cross-cluster federation capabilities to store your Kubernetes metrics over a long period of time. 
👉 [Thano's GitHub](https://github.com/thanos-io/thanos) 

### Grafana
[Grafana](https://grafana.com) is a visualization tool that can be used with Prometheus to create dashboards and visualizations of your Kubernetes metrics, making it smoother to understand the health and performance of your applications. 
👉 [Grafana's GitHub](https://github.com/grafana/grafana) 

### Kubevisor
[Kubevisor](https://kubevisor.io) is a lightweight and extensible Kubernetes resource monitor that provides real-time insights into the health and performance infrastructure. You can visualize resource usage and metrics, set alerts and thresholds, and troubleshoot issues quickly. Kubevisor supports many popular Kubernetes distributions and can be integrated with Prometheus and Grafana. 
👉 [Kubevisor's GitHub](https://github.com/kubevisor/kubevisor)


### Sysdig
[Sysdig](https://sysdig.com) unifies visibility, security, and compliance for Kubernetes and other cloud-native technologies. It allows you to monitor your Kubernetes infrastructure and applications in real-time, detect security threats and vulnerabilities, and enforce compliance policies. Sysdig provides a set of features for monitoring and observability, including container visibility, network security, and compliance auditing. 
👉 [Sysdig's GitHub](https://github.com/sysdiglabs) 



## Logging and tracing 

### Elasticsearch
[Elasticsearch](elastic.co) is a search engine that can be used to store and search logs generated by Kubernetes resources. It simplifies the management and search of logs in Kubernetes to troubleshoot issues in your applications. 
👉 [Elasticsearch's GitHub](https://github.com/elastic/elasticsearch)

### Fluentd
[Fluentd](https://www.fluentd.org) is a data collection tool that can collect logs and send them to Elasticsearch or other destinations. 
👉 [Fluentd's GitHub](https://github.com/fluent/fluentd) 


### Jaeger
[Jaeger](https://www.jaegertracing.io) is a distributed tracing system that can be used to monitor the performance of your Kubernetes applications by tracing requests through your Kubernetes cluster, making it easy to identify performance bottlenecks and troubleshoot issues. 
👉 [Jaeger's GitHub](https://github.com/jaegertracing/jaeger) 

### OpenTelemetry
[OpenTelemetry](https://opentelemetry.io) provides a vendor-neutral and language-agnostic way to collect, process, and export telemetry data to collect logs, traces, and metrics from your  applications and infrastructure, and export them to popular observability platforms such as Prometheus and Grafana. 👉 [OpenTelemetry's GitHub](https://github.com/open-telemetry) 

### Fluent Bit
[Fluent Bit](https://fluentbit.io) is a lightweight and high-performance log and event collector that supports many popular logging systems and formats. With Fluent Bit, you can collect and process logs from your Kubernetes applications and infrastructure, and export them to popular logging platforms such as Elasticsearch and Splunk. 
👉 [Fluent Bit's GitHub](https://github.com/fluent/fluent-bit) 


## Networking and service discovery 

### CoreDNS
[CoreDNS](https://coredns.io) is a DNS server that can be used to provide service discovery within your Kubernetes cluster to manage DNS records for your Kubernetes resources, making it easy to discover and communicate with services within your cluster. 
👉 [CoreDNS's GitHub](https://github.com/coredns/coredns)

### Traefik
[Traefik](https://traefik.io) is a reverse proxy and load balancer that can be used to manage network traffic between Kubernetes resources to manage network traffic and enforce security policies to secure and optimize communication between your Kubernetes resources. 
👉 [Traefik's GitHub](https://github.com/traefik/traefik)

### Istio
[Istio](https://istio.io) is a service mesh that can be used to manage and secure communication between services within your Kubernetes cluster to manage traffic routing, load balancing, and security policies. 
👉 [Istio's GitHub](https://github.com/istio/istio)

### Contour
[Contour](https://projectcontour.io) is a Kubernetes ingress controller that provides a high-performance and scalable way to manage incoming traffic. Contour supports many popular features, such as TLS termination, load balancing, and path-based routing. 
👉 [Contour's GitHub](https://github.com/projectcontour/contour)

## Security 

### Kubernetes Secrets
[Kubernetes Secrets](https://kubernetes.io/docs/concepts/configuration/secret) is a tool that can be used to store and manage sensitive information like passwords and API keys. It provides a simple and secure way to manage secrets within your Kubernetes cluster to protect sensitive information. 
👉 [Kubernetes Secrets's GitHub](https://github.com/kubernetes/kubernetes) 

### RBAC (Role-Based Access Control)
[RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac) is a security mechanism that can be used to control access to Kubernetes resources based on roles and permissions to manage access control within your Kubernetes cluster, making it easy to enforce security policies. 
👉 [RBAC's GitHub](https://github.com/kubernetes/kubernetes) 

### Open Policy Agent (OPA)
[OPA](https://www.openpolicyagent.org) is a policy engine that can be used to enforce security policies and access control within your Kubernetes cluster to define policies, which can be used to enforce security and compliance requirements. 
👉 [OPA's GitHub](https://github.com/open-policy-agent/opa) 

### Kyverno
[Kyverno](https://kyverno.io) is a policy engine designed for Kubernetes to ensure compliance and security for your Kubernetes infrastructure and applications. Kyverno is easy to deploy and configure and provides a powerful set of features for policy enforcement. 
👉 [Kyverno's GitHub](https://github.com/kyverno/kyverno)

### Gatekeeper
Gatekeeper is a policy engine designed for Kubernetes. It provides a way to enforce policies and rules for Kubernetes resources using the Open Policy Agent (OPA) engine. With Gatekeeper, you can ensure compliance and security for your Kubernetes infrastructure and applications. 
👉 [Gatekeeper's GitHub](https://github.com/open-policy-agent/gatekeeper)


## Continuous integration/Continuous deployment 

### Dagger
[Dagger](https://dagger.io/) is a Kubernetes-native deployment tool that simplifies the deployment and management of applications on Kubernetes. With Dagger, you can define and deploy complex applications in minutes, without the need for complex YAML files or custom scripts. It provides a simple and intuitive user interface for managing deployments, with real-time monitoring and logging. 
👉 [Dagger's GitHub](https://github.com/dagger/dagger)


### Jenkins
[Jenkins](https://www.jenkins.io) is a popular CI/CD tool that can be used to automate the process of building, testing, and deploying your applications to Kubernetes. It provides a simple and flexible way to define pipelines, which can be used to automate the entire software delivery process. 
👉 [Jenkins's GitHub](https://github.com/jenkinsci/jenkins) 

### GitLab
[GitLab](https://about.gitlab.com) is a platform that provides CI/CD pipelines for building, testing, and deploying your applications to Kubernetes. It provides a simple and powerful way to manage your source code and automate the software delivery process.
👉 [GitLab's GitHub](https://github.com/gitlabhq/gitlabhq) 

### Argo CD
[Argo CD](https://argoproj.github.io/cd/) is a tool that can be used to automate the deployment of your applications to Kubernetes by using GitOps principles. It provides a simple and powerful way to manage the deployment of your applications, making it easy to ensure consistency and reliability. 
👉 [Argo CD's GitHub](https://github.com/argoproj/argo-cd) 


### Tekton
[Tekton](https://tekton.dev) is an open source framework for building CI/CD pipelines on Kubernetes to define and execute pipelines using Kubernetes resources. Tekton is gaining popularity as more organizations adopt Kubernetes for CI/CD. 
👉 [Tekton's GitHub](https://github.com/tektoncd/pipeline)


## Infrastructure-as-Code (IaC)

### Terraform
[Terraform](https://www.terraform.io) is a tool that can be used to define and manage your Kubernetes infrastructure as code, making it easy to provision and manage your Kubernetes cluster and associated resources.
Learn how to deploy your Terraform module in a few click with our [guided hands-on here](https://www.scaleway.com/en/blog/terraform-module-deploy-your-infrastructure-in-one-click/).
👉 [Terraform's GitHub](https://github.com/hashicorp/terraform) 

### Ansible
[Ansible](https://www.ansible.com) is a tool that can be used to automate the provisioning and configuration of your Kubernetes resources. It provides a simple and powerful way to manage your infrastructure, making deploying and managing your Kubernetes resources easy. 
👉 [Ansible's GitHub](https://github.com/ansible/ansible) 

### Pulumi
[Pulumi](https://www.pulumi.com) is a tool that can be used to create and manage your Kubernetes resources using familiar programming languages like Python and JavaScript. 
👉 [Pulumi's GitHub](https://github.com/pulumi/pulumi)

### Crossplane
[Crossplane](https://crossplane.io) is an open source platform for managing cloud-native infrastructure that helps to manage infrastructure across multiple clouds. Crossplane is gaining popularity as more organizations [adopt multi-cloud strategies](https://www.scaleway.com/en/blog/k8s-multi-cloud/). 
👉 [Crossplane's GitHub](https://github.com/crossplaneio/crossplane) 


## Final thoughts

The momentum Kubernetes has right now is driving so many positive things. Every vendor is taking a Kubernetes-first approach to building their solutions and tools. For example, modern applications are being built and packaged to run on Kubernetes, and most innovations in areas like security and development are being built around Kubernetes. As well as this, every major cloud offers its own Kubernetes services. The ecosystem is huge, it’s still growing, and it’s very welcoming. That last bit is helping lower the entry barrier and allowing more people to enter.

As Kubernetes continues to evolve, we can expect even more exciting developments and advancements to emerge. It's an exciting time to be part of the Kubernetes community, and we look forward to seeing the new tools and solutions that will be developed in the future.










large_Kubernetes blog1.png

medium_Kubernetes blog1.png

small_Kubernetes blog1.png

thumbnail_Kubernetes blog1.webp

Kubernetes blog1.webp

kubernetes-tooling-open-source

Today marks one year since Scaleway’s Serverless Functions and Containers entered General Availability. We’ve achieved a lot in the past year, and we’re only just getting started. In the serverless team, we don't see serverless as a single product, but as an ecosystem, driven by a philosophy of making the cloud easier to use, more efficient, but also more affordable to use., we are committed to delivering a set of services and frameworks that provide a complete serverless experience to a diverse range of applications. In this post we’ll describe the big ideas behind the serverless ecosystem, where we are today, and where we’re going in the future. 

## Making the cloud feel like one big operating system 
Writing and running code on a laptop is exactly that, writing the code, then telling the operating system to run it. Developers don't need to specify how to configure or share the underlying resources, which bits of the system to interface with, or what limits they want to enforce. It’s so simple that even children can do it. Serverless is about bringing this same simplicity to the cloud, making it as simple as running an application on your laptop. This means users can focus on writing code, while the serverless platform handles the rest. This means provisioning, configuring, and scaling whatever underlying infrastructure is needed, billing the user only for what they use, and cleaning up afterwards. 

We still have a way to go before we achieve the serverless dream, and today serverless is still synonymous with just two products: function-as-a-service, and container-as-a-service. Both represent a significant step forward in shielding the user from complexity, allowing them to focus on writing code, and billing them only for what they use. However, functions and containers are just the foundations of the larger serverless ecosystem. To provide a complete serverless experience, we must also consider how we compose functions and containers into larger workflows, how we manage state and scale our storage, how we can make it easy to port existing applications, and how we can write new applications for this novel environment. 

## How we built our Serverless foundations: Functions and Containers 

Just as you can’t build a house on shaky foundations, you can’t build a serverless ecosystem without a solid base. In serverless, this base is Functions-as-a-Service and Containers-as-a-Service. These are the workhorses of serverless, executing user’s code, and scaling on demand. On top of this base of FaaS and CaaS, we can build the rest of our serverless ecosystem. We started work on our FaaS and CaaS products as early as 2019. 

Although we were quick to get to an MVP, GA was still almost two years away. These two years were spent on building the scaffolding around the core compute product, to create a secure, smooth, production-grade serverless product. Significant projects included the build-and-deploy pipeline, configuring and stress-testing our autoscaling, performance tuning and profiling, scaling the platform across multiple clusters in multiple regions, security audits, and integrating the product into the Scaleway ecosystem. At the time, the company was focused on bare metal and virtual machines, so setting up and running a scalable serverless infrastructure was a big change in mindset. 

It was also a big technical change, as we were sharing infrastructure between tenants at a much higher granularity, and dealing with high-volume, short-lived workloads. This placed increased stress on our metrics, logs, and internal APIs, and required a rethink of how we do observability and billing. It also put a strain on our nascent managed Kubernetes Service, with the volume of containers regularly causing headaches for the Container Registry Service. We launched the working beta in the summer of 2020. 

The platform was slow during the first weeks due to unexpected consumption from the beta testers and we ran into several scaling issues. Through more than a year of beta tests, we gathered lots of feedback on how we could build an even better and more innovative product. Some of the ideas that came out of this process are still in the pipeline, so watch this space! Finally, after two years of work and a last minute bug that almost crashed the product, we were happy to release our serverless platform to the world. Scaleway’s Serverless Functions and Containers entered GA in November 2021. 

Since then, we have continuously added features to make our products more performant, flexible, powerful, and easy-to-use. Although we will continue to add features to make these foundations even better (such as support for public and private container registries, new language runtimes, and improved logging and metrics), we are now in the next phase of building our serverless ecosystem. 

## What’s next in the serverless ecosystem? 

Now that we have a solid foundation in place with Serverless Functions and Containers, we can look to the future of serverless, and what that means for the rest of the ecosystem at Scaleway. We have worked closely with existing users of both serverless and non-serverless products to determine how our serverless ecosystem can best suit their needs. As a result of these consultations, we are now working on a number of products and enhancements that will allow users to build more complex applications, at larger scale, with more data, and more resources. We can break this work down into 5 categories: workflows, storage, programming, developer experience, and performance. ## Workflows Although users can achieve a lot with single functions and containers, the real power of serverless comes from orchestrating multiple functions and containers as part of larger workflows. These workflows can be used for any multi-stage task, from downstream data processing pipelines, to multi-stage image compression and analysis, to distributed machine learning training. Serverless workflows cannot be configured without suitable plumbing to pass data between stages. This is where Scaleway’s new Messaging and Queueing service comes into play. Part of the next phase of our serverless ecosystem is a serverless orchestrator, built on messaging and queueing, which lets users connect functions and containers to a number of different event sources, including queues, publish-subscribe, and Amazon S3 events. 

## State and storage 
Compute isn’t much use without access to data, so in addition to serverless functions and containers, we need to provide serverless storage. Serverless storage shares many of the properties as serverless compute, namely users don’t have to provision or scale the underlying infrastructure, and they pay only for what they use. Object storage has provided a form of serverless storage for several years at Scaleway, but object storage is only part of the story. To broaden our serverless storage offering at Scaleway, we are working on a new line of serverless NoSQL/SQL databases, which will offer the same auto-scaling, pay-as-you-go experience as Serverless Functions and Containers. 
With combined serverless compute and storage, users can build front-to-back data driven applications without configuring any infrastructure. For example, Lego only uses serverless resources (functions, databases, storage) and managed services (API gateway, Messaging, Emailing …) to run its whole e-commerce platform. This enabled them to create an efficient applications that use few resources most of the year while being able to scale to match customers demand during the Black Friday or the Christmas season. 

## Building new applications and porting existing applications 

Today’s serverless programming model is built on stateless functions. Each function can’t communicate with others, and must be able to operate at arbitrary scale. While this is a powerful tool for certain applications, it makes it difficult to port many existing applications, and presents a steep learning curve for non-serverless developers. Indeed as of today, to maximize Serverless benefits, one must think in terms of small single-purpose functions and how to orchestrate them. As is the case in other distributed and parallel execution environments, we want to support a range of different programming models and applications, not just those built on stateless functions. 
To do this, we are focusing on two themes: a) building new programming models specifically for serverless b) supporting existing applications written for other execution environments. New serverless programming models are those that take advantage of the effectively limitless scaling of the serverless execution environment, inspired by ideas from actor-based parallelism, and messaging passing frameworks. These often cater to distributed, highly parallel applications such as scientific simulations and distributed ML training built on MPI. Porting existing applications means providing seamless integration with other parallel and distributed programming frameworks. Applications built on top of these frameworks can then change a line of config, to switch from their existing execution environment, to the new serverless backend. Two good examples of such frameworks are Spark and Dask, used extensively by data scientists. By porting these frameworks to serverless, we can open up the potential of serverless to a large number of new users and use-cases. 

## Developer experience 
The serverless developer experience is different from that encountered in many other execution environments. By definition, serverless applications are distributed, and run in an environment that is controlled by the provider. This exacerbates challenges around logging, debugging, and monitoring, similar to those found in microservice architectures, especially those relying on Cloud Service Providers services. In particular to verify that the service (function) developed still works in the provider's environment users are required to deploy it, increasing the time to get debugging information hence breaking the code/run/improve loop. 

To improve the serverless developer experience and fulfill the promise of a seamless experience, we are working on a number of tools and enhancements. The first of these is offline development and testing. The serverless execution environment is defined and controlled by the provider, and so replicating it on a local development machine can be challenging. 
We are building tools to help developers get meaningful feedback from their development environment, without having to redeploy functions remotely. The second improvement we are making in this area is monitoring and logging. By integrating with Scaleway’s Observability Platform-as-a-service, we will provide users with a detailed overview of their serverless functions, along with logs and metrics that can help them manage this distributed environment. 

## Performance 
Performance in serverless is often distilled down to a single problem, that of cold starts. Although cold starts are an important factor, especially in user-facing applications, serverless performance also covers scale-out latency, build times, and latency when interacting with the rest of the ecosystem. These performance concerns are multiplied for every container and function that is added to an application, so it’s important for us to ensure high performance when considering serverless at scale. Our work in this area covers two areas: reducing the build, deployment and invocation time of our existing architecture, and researching new architectures, such as those based on WebAssembly. Reducing the latency in our existing architecture involves caching, pooling and simply reducing the resources needed to execute each function. By adding registry caches, reusing isolation environments between requests, and pooling pre-warmed VMs and containers, we can reduce the latency involved in all aspects of our serverless systems. Experimenting with lightweight isolation mechanisms such as WebAssembly, offers orders of magnitude improvements in cold start times, as well as exciting opportunities to build new custom runtime environments, with low-latency messaging, and shared memory between functions. Our research and development on new serverless runtimes is ongoing, but we hope to reveal some exciting new improvements next year. 

## Final thoughts 
Serverless is a philosophy for building cloud platforms that feel like one big operating system. At Scaleway we’re committed to delivering an ecosystem of products that adhere to this philosophy, allowing users to build large, scalable, stateful applications as simply and affordably as possible. In one short year we’ve built two products that form the foundation of this ecosystem: Serverless Functions and Serverless Containers. There’s much, much more to come, so watch this space, and thank you for joining us on the journey.

large_Corpo-Space-Illustration-Blog.webp

medium_Corpo-Space-Illustration-Blog.webp

small_Corpo-Space-Illustration-Blog.webp

thumbnail_Corpo-Space-Illustration-Blog.webp

Corpo-Space-Illustration-Blog.webp

1-year-anniversary-serverless-blog-post

For startups, finding the right tools to build and deploy their applications can be a daunting task. With limited budgets and resources, it's crucial to make the right choices that will drive the business forward without breaking the bank. 

The open source community offers a vast array of tools and projects that can help builders to launch their applications quickly and efficiently. Supporting open source projects is not only cost-effective but also encourages collaboration, innovation, and knowledge sharing among developers. Open source projects are often maintained by passionate volunteers committed to creating high-quality, reliable software that can be used by anyone. Additionally, open source software is transparent and can be audited by anyone, reducing the risk of security vulnerabilities. 

By using open source tools, startups can reduce their costs, build better software, and contribute to the broader tech community. 

In this post, we'll explore some of the best open source projects available that can help startups get up and running in no time. You can also find on [Scaleway's Github](https://github.com/scaleway) what we are currently working on.

## Open source CMS & web tools 🌏 
* [**Strapi**](https://strapi.io/) \- Node.js Headless CMS to build customizable APIs. Check out this tutorial if you are looking to [self-host Strapi on a Scaleway Instance](https://www.scaleway.com/en/docs/tutorials/strapi/). 
* [**Builder**](https://builder.io/) \- Drag and drop page builder and CMS.
* [**Plasmic**](https://plasmic.app/) \- The headless page builder for singe-page frameworks.
* [**Directus**](https://directus.io/) \- Open Data Platform for instantly turning any SQL database into an API and beautiful no-code app.
* [**Webiny**](https://www.webiny.com/) \- Enterprise serverless CMS.
* [**Hoppscotch**](https://hoppscotch.io/) \- API development ecosystem to help create requests faster, saving precious time on development.
* [**Keycloak**](https://www.cloud-iam.com/) \- User authentication and session management framework.
* [**Appwrite**](https://appwrite.io/) \- Backend server with REST APIs to manage core backend needs.
* [**Supabase**](https://supabase.com/) \- The alternative to Firebase to create a backend in two minutes.
* **[Nextcloud](https://nextcloud.com/)** \- Self-hosted productivity platform solution.
* [**Medusa**](https://github.com/medusajs/medusa) \- The open source alternative to Shopify to build an ecommerce store in a few minutes.


## Infrastructure, analytics & observability 📊 
* **[Netbox](https://github.com/netbox-community/netbox)** \- Infrastructure resource modeling application designed to empower network automation. 
* [**Signoz**](https://signoz.io/) \- Open-source APM to monitor applications & troubleshoot problems.
* [**Grafana**](https://grafana.com/) \- Open source analytics & monitoring solution for every database.
* [**Sentry**](https://sentry.io/) \- Application monitoring and error tracking software.
* [**Plausible**](https://plausible.io/) \- Analytics tool you can use to check web traffic. It is a simple, lightweight and privacy-friendly Google Analytics alternative.
* [**Preset**](https://www.preset.io/) \- Modern BI platform powered by Apache Superset.
* [**Matomo**](https://matomo.org/) \- Google Analytics alternative that protects your data and your customers' privacy.
* [**PostHog**](https://posthog.com/) \- Product analytics platform.
* **[Prometheus](https://prometheus.io/)** \- Monitoring system with a dimensional data model, flexible query language, efficient time series database and modern alerting approach.
* **[Pulumi](https://www.pulumi.com/)** \- Infrastructure as Code SDK to create and deploy cloud software that use containers, serverless functions, hosted services, and infrastructure, on any cloud.

## Customer engagement and data platform 📈 
* [**Odoo**](https://www.odoo.com/) \- Business apps that cover all your company needs: CRM, eCommerce, accounting, inventory, point of sale, project management, etc.
* [**Rudderstack**](https://www.rudderstack.com/) \- All your customer data pipelines in one platform.
* [**Chatwoot**](https://www.chatwoot.com/) \- Live chat widget.
* [**Jitsu**](https://jitsu.com/) \- Fully-scriptable data ingestion engine for modern data teams.
* [**Rudderstack**](https://rudderstack.com/) \- Customer data platform for developers.

## Cybersecurity 🛡
* [**CloudQuery**](https://cloudquery.io/) \- Assess, audit, and evaluate the configurations of your cloud assets.
* [**CrowdSec**](http://crowdsec.net/) \- Collaborative IPS able to analyze visitor behavior and to provide an adapted response to all kinds of attacks.
* [**Firezone**](https://www.firez.one/) \- VPN Server & Firewall for teams.
* **[Gravitl](https://gravitl.com/)** \- WireGuard virtual networking platform (VPN).
* **[Nikto](https://github.com/sullo/nikto)** \- Web server scanner which performs comprehensive tests against web servers for multiple items.
* **[Wireshark](https://www.wireshark.org/)** \- network protocol analyzer to see what's happening on your network at a microscopic level.

## Design, product management & tooling 🛠

* [**Penpot**](https://penpot.app/) \- Design & prototyping platform, a great open source alternative to Figma.  
[Learn how to self-host Penpot using the Docker InstantApp](https://www.scaleway.com/en/docs/tutorials/deploy-penpot-with-docker-instantapp/)
* **[Budibase](https://budibase.com/)** \- Low-code platform for internal tools.
* [**Gimp**](https://www.gimp.org/downloads/) \- A powerful open source photo and image editing tool.
* [**Jitsi**](https://jitsi.org/meet) \- Video conferences platform and SDK. 
* [**BigBluebutton**](https://bigbluebutton.org/) \- Virtual classroom software that can be used for remote meeting or events.
* [**OpenProject**](https://www.openproject.org/) \- Project management software. Efficient classic, agile or hybrid project management in a secure environment.
* [**Focalboard**](https://www.focalboard.com/) \- Alternative to Trello, Notion, and Asana - helps software development team stay aligned to complete tasks, reach milestones, and achieve goals.
* **[Mattermost](https://mattermost.com/)** \- secure, open source platform for communication, collaboration, and workflow orchestration across tools and teams.
* **[Renovate](https://docs.renovatebot.com/)** \- Get automated Pull Requests to update your dependencies.
* **[Libreoffice](https://fr.libreoffice.org/download/telecharger-libreoffice/)** \- Office and productivity suite.
* **[Gitlab](https://gitlab.com/gitlab-org/gitlab)** \- end-to-end software development platform with built-in version control, issue tracking, code review and CI/CD.
* [**Taiga.io**](https://www.taiga.io/) \- Easy and intuitive open source project management software for agile teams. Kanban or scrum.


## Where to deploy?

If you are looking for the proper ally to deploy your project on, you might want to look into our range of [Virtual Instances](https://www.scaleway.com/en/virtual-instances/). We divided in four main categories to help you navigate among all the different specs. 

### Learning
The Instances from the [Learning](https://www.scaleway.com/en/docs/compute/instances/reference-content/learning/) range are perfect for small workloads and simple applications. They are built to host small internal applications, staging environments, or low-traffic web servers.

### Cost-Optimized
The [Cost-Optimized](https://www.scaleway.com/en/docs/compute/instances/reference-content/cost-optimized/) range balances compute, memory, and networking resources. They can be used for a wide range of workloads - scaling a development and testing environment, but also Content Management Systems (CMS) or microservices. They're also a good default choice if you need help determining which instance type is best for your application.

### Production-Optimized
The [Production-Optimized](https://www.scaleway.com/en/docs/compute/instances/reference-content/production-optimized/) range includes the highest consistent performance per core to support real-time applications, like Enterprise Instances. In addition, their computing power makes them generally more robust for compute-intensive workloads.

### Workload-Optimized
Expanding the Production-Optimized range, the Worload-Optimized range will be launched in the near future and will provide the same highest consistent performance than the Production-Optimized instances But they will come with the added flexibility of additional vCPU:RAM ratio in order to perfectly fits to your application’s requirements without wasting any vCPU or GB of RAM ressources.

large_OpenSource-Woman-Illustration-Blog.webp

medium_OpenSource-Woman-Illustration-Blog.webp

small_OpenSource-Woman-Illustration-Blog.webp

thumbnail_OpenSource-Woman-Illustration-Blog.webp

OpenSource-Woman-Illustration-Blog.webp

40-open-source-projects

## Incident Overview
Between September, 24 and October, 23 2024, Scaleway Object Storage encountered a period of increased instability in the FR-PAR region following architectural upgrades aimed at enhancing performance and scalability. During this time, some customers experienced elevated error rates and increased upload latency.

Incident status links:
- [https://status.scaleway.com/incidents/938lgd7wn1zg](https://status.scaleway.com/incidents/938lgd7wn1zg)
- [https://status.scaleway.com/incidents/b4dw2zl83837](https://status.scaleway.com/incidents/b4dw2zl83837)

**Regions Impacted**: FR-PAR
**Duration**: 7 days until mitigation, 1 month to get back to nominal performances
**Primary Impact**: Instability and increased latency on S3 upload performance, affecting certain users.

## Summary of Events
In September 2024, we initiated a series of infrastructure improvements for Scaleway Object Storage, including the migration of PUT methods to our new Object Storage gateway and the deployment of an upgraded load-balancing architecture in the FR-PAR region. These changes were designed to reduce latency and improve scalability, as successfully observed in prior rollouts in other regions (NL-AMS and PL-WAW).
However, after scaling up the deployment in the FR-PAR region on September 23, we observed an unexpected increase in 503 errors, indicating instability. Initial analysis showed that the FR-PAR region's higher load conditions made it particularly susceptible to unforeseen issues, despite thorough monitoring during earlier deployments. The migration could not be reverted due to the architectural complexity of the update, leading to a longer mitigation delay than usual.

## Incident Timeline
- September 18, 2024: Migration of PUT methods to the new Object Storage Gateway completed in FR-PAR
- September 23, 2024: New load balancer architecture deployed in FR-PAR to handle increased request volumes
- September 25, 2024: Initial incident opened following increased 503 errors. A patch was deployed but did not fully resolve the issue
- September 28, 2024: Second incident opened. Another patch deployed but rolled back due to unintended side effects
- September 30, 2024: Final mitigation patch deployed, temporarily stabilizing the service but causing a slight increase in latency
- October 4, 2024: Partial hardware mitigation implemented in FR-PAR, yielding significant performance improvements
- October 7-8, 2024: Additional upgrades were made to the new load balancers servers (upgrading from 64GB to 512GB of RAM) to resolve memory-related issues
- October 23, 2024: Full deployment of the long-term fix across all impacted regions, restoring performance to optimal levels.

## Root Cause Analysis
1. Increased Load on FR-PAR: The unique conditions in the FR-PAR region, particularly higher request loads, revealed an unexpected sensitivity in our infrastructure that was not observed during earlier regional deployments
2. Memory Limitations: New load balancer servers in FR-PAR were initially provisioned with 64GB of RAM, which proved insufficient under suddenly higher traffic conditions, leading to memory exhaustion and early-termination of processes
3. Connection Management: Issues with HTTP Keep-Alive timeout settings between our new Gateway and load balancers led to inefficient handling of some client requests, exacerbating latency issues
4. Patch and Rollback Challenges: Although multiple patches were quickly developed, early solutions had to be rolled back due to unintended side effects. Also, no rollback was possible for the initial architectural upgrades, prolonging the resolution.

## Impact on Customers
During this period, customers in the FR-PAR region may have observed:
- Elevated 503 errors and occasional request failures, particularly during peak hours
- Increased latency on object uploads, with temporary performance degradation.
Customers were advised to implement retries on failed requests to mitigate the impact, as further optimizations were implemented.

## Resolution and Improvements
The resolution involved:
- Memory Upgrades: New load balancers  servers in FR-PAR were upgraded from 64GB to 512GB, significantly improving stability under high loads
- Enhanced Connection Management: HTTP Keep-Alive settings were fine-tuned between the Object Storage gateway and load balancers, which improved response times and connection stability
- Improved Fault Tolerance: A new upload mechanism was developed, enhancing the fault tolerance of PUT operations, particularly in handling intermittent errors.

These improvements culminated in a full resolution of the incident on October 23, 2024. Performance gain was confirmed in FR-PAR compared to before the architectural upgrades that had triggered the incident. Customer feedback quickly confirmed satisfaction with the overall optimization of the service.

## Customer Support and SLAs
Despite this incident, we maintained overall SLA compliance for September (99.93% uptime against a 99.0% SLA target for single-zone and 99.90% for multi-AZ configurations). October overall SLA was not deteriorated by the incident.

## Next Steps and Continuous Improvement
This incident has highlighted areas where we can enhance both our infrastructure and our processes. As part of our commitment to continuous improvement, we are:
- Strengthening our monitoring and alerting to detect similar issues earlier in the deployment cycle
- Implementing a more robust change-management process to improve rollback options for complex architectural upgrades
- Exploring advanced deployment methods, including blue-green deployments
- Improving external communication before impacting production deployment (maintenance windows).  

We remain dedicated to delivering reliable and performant Object Storage services to all our customers and thank you for your understanding as we continue to make improvements based on the lessons learned from this incident.


_Scaleway provides [updates in real time of all of its services’ status, here](https://status.scaleway.com/). Feel free to contact us via the [console](https://console.scaleway.com/) for any questions moving forwards. Thank you!_


Scaleway Blog

Latest articles

Update: Scaleway Object Storage incident across September & October 2024

Update: Scaleway Elements Partial Loss of VPC Connectivity in FR-PAR-1

Update: Details of “Important loss of connectivity in VPC on fr-par region” incident & response

Update: Kapsule & Kosmos incident in FR-PAR region & response

Update: FR-PAR Kapsule API incident & response

Update: Details of “Instabilities on DHCP fr-par and api.scaleway.com” incident & response

Update: Block Storage incident on AMS-1

Update: Deprecation of public-only Kapsule clusters

Most popular articles

Top open-source Kubernetes management tools

Serverless: 1 year in, and we’re just getting started

40+ of the best open-source tools to build your startup