concise commandline monitoring for containers.
Top-like interface for container metrics. ctop comes with built-in support for Docker and runC. As well as a single container view for inspecting a specific container.
Connectors for other container and cluster systems are planned for future releases.
https://github.com/bcicen/ctop
#go #devops #docker
Top-like interface for container metrics. ctop comes with built-in support for Docker and runC. As well as a single container view for inspecting a specific container.
Connectors for other container and cluster systems are planned for future releases.
https://github.com/bcicen/ctop
#go #devops #docker
HTTPie—aitch-tee-tee-pie—is a user-friendly command-line HTTP client for the API era. It comes with JSON support, syntax highlighting, persistent sessions, wget-like downloads, plugins, and more.
HTTPie is designed for painless debugging and interaction with APIs, HTTP servers, and web services, which it accomplishes by:
- Built-in JSON support
- Colorized and formatted terminal output
- Sensible defaults
- Persistent sessions
- Forms and file uploads
- HTTPS, proxies, and authentication support
- Support for arbitrary request data and headers
- Wget-like downloads
- Extensions API
- Expressive and intuitive syntax
- Linux, macOS, and Windows support
- All that & more in 2 simple commands: http + https
https://httpie.org/
#python
HTTPie is designed for painless debugging and interaction with APIs, HTTP servers, and web services, which it accomplishes by:
- Built-in JSON support
- Colorized and formatted terminal output
- Sensible defaults
- Persistent sessions
- Forms and file uploads
- HTTPS, proxies, and authentication support
- Support for arbitrary request data and headers
- Wget-like downloads
- Extensions API
- Expressive and intuitive syntax
- Linux, macOS, and Windows support
- All that & more in 2 simple commands: http + https
https://httpie.org/
#python
Machine Learning models should play by the rules, literally. Natural Intelligence is still a pretty good idea.
Back in the old days, it was common to write rule-based systems.
Nowadays, it's much more fashionable to use machine learning instead.
We started wondering if we might have lost something in this transition. Sure, machine learning covers a lot of ground but it is also capable of making bad decision. We've also reached a stage of hype that folks forget that many classification problems can be handled by natural intelligence too.
This package contains scikit-learn compatible tools that should make it easier to construct and benchmark rule based systems that are designed by humans. You can also use it in combination with ML models.
This tool allows you to draw over your datasets. These drawings can later be converted to models or to preprocessing tools.
https://koaning.github.io/human-learn/
#python #ds
Back in the old days, it was common to write rule-based systems.
Nowadays, it's much more fashionable to use machine learning instead.
We started wondering if we might have lost something in this transition. Sure, machine learning covers a lot of ground but it is also capable of making bad decision. We've also reached a stage of hype that folks forget that many classification problems can be handled by natural intelligence too.
This package contains scikit-learn compatible tools that should make it easier to construct and benchmark rule based systems that are designed by humans. You can also use it in combination with ML models.
This tool allows you to draw over your datasets. These drawings can later be converted to models or to preprocessing tools.
https://koaning.github.io/human-learn/
#python #ds
Public release of the TransCoder research project https://arxiv.org/pdf/2006.03511.pdf
Pytorch original implementation of TransCoder in Unsupervised Translation of Programming Languages.
https://github.com/facebookresearch/TransCoder
Pytorch original implementation of TransCoder in Unsupervised Translation of Programming Languages.
https://github.com/facebookresearch/TransCoder
⚡Breaking news!
Webpack 5 is released!
webpack 4 was released in February 2018. Since then we shipped a lot of features without breaking changes. We know that people dislike major changes with breaking changes. Especially with webpack, which people usually only touch twice a year, and the remaining time it "just works". But shipping features without breaking changes also has a cost: We can't do major API or architectural improvements.
So from time to time, there is a point where the difficulties pile up and we are forced to do breaking changes to not mess everything up. That's the time for a new major version. So webpack 5 contains these architectural improvements and the features that where not possible to implement without them.
The major version was also the chance to revise some of the defaults and to align with proposals and specifications that come up in the meantime.
So today (2020-10-10) webpack 5.0.0 is released, but this doesn't mean it's done, bugfree or even feature-complete. As with webpack 4 we continue development by fixing problems and adding features. In the next days there will probably a lot bugfixes. Features will come later.
This release focus on the following:
- Improve build performance with Persistent Caching.
- Improve Long Term Caching with better algorithms and defaults.
- Improve bundle size with better Tree Shaking and Code Generation.
- Improve compatibility with the web platform.
- Clean up internal structures that were left in a weird state while implementing features in v4 without introducing any breaking changes.
- Prepare for future features by introducing breaking changes now, allowing us to stay on v5 for as long as possible.
https://webpack.js.org/blog/2020-10-10-webpack-5-release/
However, webpack@5 raised a lot of discussions because of its breaking changes.
See this article (from Sindre Sorhus) for example: https://blog.sindresorhus.com/webpack-5-headache-b6ac24973bf1
Webpack 5 is released!
webpack 4 was released in February 2018. Since then we shipped a lot of features without breaking changes. We know that people dislike major changes with breaking changes. Especially with webpack, which people usually only touch twice a year, and the remaining time it "just works". But shipping features without breaking changes also has a cost: We can't do major API or architectural improvements.
So from time to time, there is a point where the difficulties pile up and we are forced to do breaking changes to not mess everything up. That's the time for a new major version. So webpack 5 contains these architectural improvements and the features that where not possible to implement without them.
The major version was also the chance to revise some of the defaults and to align with proposals and specifications that come up in the meantime.
So today (2020-10-10) webpack 5.0.0 is released, but this doesn't mean it's done, bugfree or even feature-complete. As with webpack 4 we continue development by fixing problems and adding features. In the next days there will probably a lot bugfixes. Features will come later.
This release focus on the following:
- Improve build performance with Persistent Caching.
- Improve Long Term Caching with better algorithms and defaults.
- Improve bundle size with better Tree Shaking and Code Generation.
- Improve compatibility with the web platform.
- Clean up internal structures that were left in a weird state while implementing features in v4 without introducing any breaking changes.
- Prepare for future features by introducing breaking changes now, allowing us to stay on v5 for as long as possible.
https://webpack.js.org/blog/2020-10-10-webpack-5-release/
However, webpack@5 raised a lot of discussions because of its breaking changes.
See this article (from Sindre Sorhus) for example: https://blog.sindresorhus.com/webpack-5-headache-b6ac24973bf1
webpack
Webpack 5 release (2020-10-10) | webpack
webpack is a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser, yet it is also capable of transforming, bundling, or packaging just about any resource or asset.
Run macOS software on Linux!
Darling is a translation layer that lets you run macOS software on Linux.
Features:
- Fast: Darling runs macOS software directly without using a hardware emulator.
- Free: Like Linux, Darling is free and open-source software. It is developed openly on GitHub and distributed under the GNU GPL license version 3.
- Compatible: Darling implements a complete Darwin environment. Mach, dyld, launchd — everything you'd expect.
- Easy to use: Darling does most of the setup for you. Sit back and enjoy using your favorite software.
- Native: We aim to fully integrate apps running under Darling into the Linux desktop experience by making them look, feel and behave just like native Linux apps.
https://www.darlinghq.org/
Darling is a translation layer that lets you run macOS software on Linux.
Features:
- Fast: Darling runs macOS software directly without using a hardware emulator.
- Free: Like Linux, Darling is free and open-source software. It is developed openly on GitHub and distributed under the GNU GPL license version 3.
- Compatible: Darling implements a complete Darwin environment. Mach, dyld, launchd — everything you'd expect.
- Easy to use: Darling does most of the setup for you. Sit back and enjoy using your favorite software.
- Native: We aim to fully integrate apps running under Darling into the Linux desktop experience by making them look, feel and behave just like native Linux apps.
https://www.darlinghq.org/
List of Microservice API Patterns.
Our Microservice API Patterns (MAP) capture proven solutions to design problems commonly encountered when specifying, implementing and maintaining message-based APIs.
MAP focusses on message representations – the payloads exchanged when APIs are called. These payloads vary in their structure as API endpoints and their operations have different architectural responsibilities. The chosen representation structures strongly influence the design time and runtime qualities of an API. The evolution of API specifications and their implementations has to be governed.
https://microservice-api-patterns.org/
Our Microservice API Patterns (MAP) capture proven solutions to design problems commonly encountered when specifying, implementing and maintaining message-based APIs.
MAP focusses on message representations – the payloads exchanged when APIs are called. These payloads vary in their structure as API endpoints and their operations have different architectural responsibilities. The chosen representation structures strongly influence the design time and runtime qualities of an API. The evolution of API specifications and their implementations has to be governed.
https://microservice-api-patterns.org/
Inertia.js: the modern monolith. Build single-page apps, without building an API.
Inertia.js lets you quickly build modern single-page React, Vue and Svelte apps using classic server-side routing and controllers.
Inertia is a new approach to building classic server-driven web apps. We call it the modern monolith.
Inertia allows you to create fully client-side rendered, single-page apps, without much of the complexity that comes with modern SPAs. It does this by leveraging existing server-side frameworks.
Inertia has no client-side routing, nor does it require an API. Simply build controllers and page views like you've always done!
Inertia isn't a framework, nor is it a replacement to your existing server-side or client-side frameworks. Rather, it's designed to work with them. Think of Inertia as glue that connects the two. Inertia does this via adapters. We currently have three official client-side adapters (#react, #vue, and #svelte) and two server-side adapters (Laravel and Rails).
https://inertiajs.com/
#js
Inertia.js lets you quickly build modern single-page React, Vue and Svelte apps using classic server-side routing and controllers.
Inertia is a new approach to building classic server-driven web apps. We call it the modern monolith.
Inertia allows you to create fully client-side rendered, single-page apps, without much of the complexity that comes with modern SPAs. It does this by leveraging existing server-side frameworks.
Inertia has no client-side routing, nor does it require an API. Simply build controllers and page views like you've always done!
Inertia isn't a framework, nor is it a replacement to your existing server-side or client-side frameworks. Rather, it's designed to work with them. Think of Inertia as glue that connects the two. Inertia does this via adapters. We currently have three official client-side adapters (#react, #vue, and #svelte) and two server-side adapters (Laravel and Rails).
https://inertiajs.com/
#js
Intuitive find & replace CLI (sed alternative) written in #rust
Why use it over any existing tools?
- Painless regular expressions. sd uses regex syntax that you already know from JavaScript and Python. Forget about dealing with quirks of sed or awk - get productive immediately.
- String-literal mode. Non-regex find & replace. No more backslashes or remembering which characters are special and need to be escaped.
- Easy to read, easy to write. Find & replace expressions are split up, which makes them easy to read and write. No more messing with unclosed and escaped slashes.
- Smart, common-sense defaults. Defaults follow common sense and are tailored for typical daily use.
Personal opinion: I had used sed a lot in the past. And I hate it. This looks like a good alternative.
https://github.com/chmln/sd
Why use it over any existing tools?
- Painless regular expressions. sd uses regex syntax that you already know from JavaScript and Python. Forget about dealing with quirks of sed or awk - get productive immediately.
- String-literal mode. Non-regex find & replace. No more backslashes or remembering which characters are special and need to be escaped.
- Easy to read, easy to write. Find & replace expressions are split up, which makes them easy to read and write. No more messing with unclosed and escaped slashes.
- Smart, common-sense defaults. Defaults follow common sense and are tailored for typical daily use.
Personal opinion: I had used sed a lot in the past. And I hate it. This looks like a good alternative.
https://github.com/chmln/sd
Flake8 plugin to find commented out or dead #python code
Part of our
https://github.com/sobolevn/flake8-eradicate
Part of our
wemake-python-styleguide project. But, you can install it independently!https://github.com/sobolevn/flake8-eradicate
A blazingly fast static web server in a single binary you can set up with zero code - written in #rust.
Features:
- Single binary with no dependencies and everything built-in.
- Blazingly fast! It's built on top of Actix, one of the fastest web frameworks in the world and of course, written in Rust.
- Everything in a single config file - everything you need to setup is in the binserve.json, just change it, run it!
- Epic Portability - just carry the binary around and all you have to change is the host and port in the binserve.json.
- Easiest Routing - you just have to enter the route and the static file to respond in the binserve.json to add a route entry!
- Handlebars template engine - renders every static file with Handlebars on the first run improving performance!
- Template Variables in one place - that too in the one and only config file!
- Secure by design - runs security validation checks on the first run and will only run the server once configuration is confirmed secure! (See Security)
- Config & Static File Assistance - just running it will create the configuration file and the static directory boilerplate for you!
- Supports Any Static Files - just give any static file of your choice to routes and response will match it's Content-Type.
- Straightforward Directory Structure - static files falls under the static directory, you can even change that! And images, css, and js falls under the assets directory which should all be created for you in the first run itself!
- Custom Error Page Support - you can design your own fancy error pages!
- Actix Logging Middleware - Logging is powered directly from Actix.
https://github.com/mufeedvh/binserve
Features:
- Single binary with no dependencies and everything built-in.
- Blazingly fast! It's built on top of Actix, one of the fastest web frameworks in the world and of course, written in Rust.
- Everything in a single config file - everything you need to setup is in the binserve.json, just change it, run it!
- Epic Portability - just carry the binary around and all you have to change is the host and port in the binserve.json.
- Easiest Routing - you just have to enter the route and the static file to respond in the binserve.json to add a route entry!
- Handlebars template engine - renders every static file with Handlebars on the first run improving performance!
- Template Variables in one place - that too in the one and only config file!
- Secure by design - runs security validation checks on the first run and will only run the server once configuration is confirmed secure! (See Security)
- Config & Static File Assistance - just running it will create the configuration file and the static directory boilerplate for you!
- Supports Any Static Files - just give any static file of your choice to routes and response will match it's Content-Type.
- Straightforward Directory Structure - static files falls under the static directory, you can even change that! And images, css, and js falls under the assets directory which should all be created for you in the first run itself!
- Custom Error Page Support - you can design your own fancy error pages!
- Actix Logging Middleware - Logging is powered directly from Actix.
https://github.com/mufeedvh/binserve
A powerful little #go TUI framework
The fun, functional and stateful way to build terminal apps. A Go framework based on The #elm Architecture. Bubble Tea is well-suited for simple and complex terminal applications, either inline, full-window, or a mix of both.
Bubble Tea is in use in production and includes a number of features and performance optimizations we’ve added along the way. Among those is a standard framerate-based renderer, a renderer for high-performance scrollable regions which works alongside the main renderer, and mouse support.
https://github.com/charmbracelet/bubbletea
The fun, functional and stateful way to build terminal apps. A Go framework based on The #elm Architecture. Bubble Tea is well-suited for simple and complex terminal applications, either inline, full-window, or a mix of both.
Bubble Tea is in use in production and includes a number of features and performance optimizations we’ve added along the way. Among those is a standard framerate-based renderer, a renderer for high-performance scrollable regions which works alongside the main renderer, and mouse support.
https://github.com/charmbracelet/bubbletea
Boundary enables identity-based access management for dynamic infrastructure.
Boundary provides simple and secure access to hosts and services.
Traditional approaches like SSH bastion hosts or VPNs require distributing and managing credentials, configuring network controls like firewalls, and exposing the private network. Boundary provides a secure way to access hosts and critical systems without having to manage credentials or expose your network, and is entirely open source.
Boundary is designed to be straightforward to understand, highly scalable, and resilient. It can run in clouds, on-prem, secure enclaves and more, and does not require an agent to be installed on every end host.
Unlike firewalls, Boundary performs per-access authentication and authorization checks, allowing for much higher level mappings of users to services or hosts than at network layers. Although complementary to secrets managers (like HashiCorp's own Vault), Boundary fills a different niche, allowing the credential that is eventually used to be hidden entirely from the user.
- Authenticate with any trusted identity provider you are already using. No need to distribute new credentials and manage them.
- Authorize access based on logical roles and services, instead of physical IP addresses. Manage dynamic infrastructure and integrate service registries so hosts and service catalogs are kept up-to-date.
- Automate credential injection to securely access services and hosts with HashiCorp Vault. Reduce risk of leaking credentials with dynamic secrets and just-in-time credentials.
https://github.com/hashicorp/boundary
#go
Boundary provides simple and secure access to hosts and services.
Traditional approaches like SSH bastion hosts or VPNs require distributing and managing credentials, configuring network controls like firewalls, and exposing the private network. Boundary provides a secure way to access hosts and critical systems without having to manage credentials or expose your network, and is entirely open source.
Boundary is designed to be straightforward to understand, highly scalable, and resilient. It can run in clouds, on-prem, secure enclaves and more, and does not require an agent to be installed on every end host.
Unlike firewalls, Boundary performs per-access authentication and authorization checks, allowing for much higher level mappings of users to services or hosts than at network layers. Although complementary to secrets managers (like HashiCorp's own Vault), Boundary fills a different niche, allowing the credential that is eventually used to be hidden entirely from the user.
- Authenticate with any trusted identity provider you are already using. No need to distribute new credentials and manage them.
- Authorize access based on logical roles and services, instead of physical IP addresses. Manage dynamic infrastructure and integrate service registries so hosts and service catalogs are kept up-to-date.
- Automate credential injection to securely access services and hosts with HashiCorp Vault. Reduce risk of leaking credentials with dynamic secrets and just-in-time credentials.
https://github.com/hashicorp/boundary
#go
Secure and fast microVMs for serverless computing.
Firecracker is an open source virtualization technology that is purpose-built for creating and managing secure, multi-tenant container and function-based services.
Firecracker enables you to deploy workloads in lightweight virtual machines, called microVMs, which provide enhanced security and workload isolation over traditional VMs, while enabling the speed and resource efficiency of containers. Firecracker was developed at Amazon Web Services to improve the customer experience of services like AWS Lambda and AWS Fargate .
Firecracker is a virtual machine monitor (VMM) that uses the Linux Kernel-based Virtual Machine (KVM) to create and manage microVMs. Firecracker has a minimalist design. It excludes unnecessary devices and guest functionality to reduce the memory footprint and attack surface area of each microVM. This improves security, decreases the startup time, and increases hardware utilization. Firecracker currently supports Intel CPUs, with AMD and Arm support in developer preview.
Firecracker is integrated with Kata Containers , Open Nebula , UniK , Weave FireKube (via Weave Ignite ), and containerd via firecracker-containerd It's also used by fly.io . Firecracker can run Linux and OSv guests.
https://github.com/firecracker-microvm/firecracker
#rust #devops
Firecracker is an open source virtualization technology that is purpose-built for creating and managing secure, multi-tenant container and function-based services.
Firecracker enables you to deploy workloads in lightweight virtual machines, called microVMs, which provide enhanced security and workload isolation over traditional VMs, while enabling the speed and resource efficiency of containers. Firecracker was developed at Amazon Web Services to improve the customer experience of services like AWS Lambda and AWS Fargate .
Firecracker is a virtual machine monitor (VMM) that uses the Linux Kernel-based Virtual Machine (KVM) to create and manage microVMs. Firecracker has a minimalist design. It excludes unnecessary devices and guest functionality to reduce the memory footprint and attack surface area of each microVM. This improves security, decreases the startup time, and increases hardware utilization. Firecracker currently supports Intel CPUs, with AMD and Arm support in developer preview.
Firecracker is integrated with Kata Containers , Open Nebula , UniK , Weave FireKube (via Weave Ignite ), and containerd via firecracker-containerd It's also used by fly.io . Firecracker can run Linux and OSv guests.
https://github.com/firecracker-microvm/firecracker
#rust #devops
Monorepo vs. polyrepo: architecture for source code management (SCM) version control systems (VCS)
Monorepo means using one repository that contains many projects, and polyrepo means using a repository per project. This page discusses the similarities and differences, and has advice and opinions on both.
https://github.com/joelparkerhenderson/monorepo_vs_polyrepo
#devops
Monorepo means using one repository that contains many projects, and polyrepo means using a repository per project. This page discusses the similarities and differences, and has advice and opinions on both.
https://github.com/joelparkerhenderson/monorepo_vs_polyrepo
#devops
Gravity is not a force.
Under general relativity, gravity is not a force. Instead it is a distortion of spacetime. Objects in free-fall move along geodesics (straight lines) in spacetime, as seen in the inertial frame of reference on the right. When standing on Earth we experience a frame of reference that is accelerating upwards, causing objects in free-fall to move along parabolas, as seen on the left.
In this system there is only one space dimension, shown on the vertical axis and labeled in meters. The time dimension is the horizontal axis and labeled in seconds. The gravitational field is constant within the area of interest.
Use this demo to see and feel this!
https://timhutton.github.io/GravityIsNotAForce/
#js
Under general relativity, gravity is not a force. Instead it is a distortion of spacetime. Objects in free-fall move along geodesics (straight lines) in spacetime, as seen in the inertial frame of reference on the right. When standing on Earth we experience a frame of reference that is accelerating upwards, causing objects in free-fall to move along parabolas, as seen on the left.
In this system there is only one space dimension, shown on the vertical axis and labeled in meters. The time dimension is the horizontal axis and labeled in seconds. The gravitational field is constant within the area of interest.
Use this demo to see and feel this!
https://timhutton.github.io/GravityIsNotAForce/
#js
> How to make CPython faster.
> We want to speed up CPython by a factor of 5 over the next four releases.
> See the plan for how this can be done.
> Making CPython faster by this amount will require funding. Relying on the goodwill and spare time of the core developers is not sufficient.
This includes JIT and other awesome features for #python
https://github.com/markshannon/faster-cpython
We need this!
> We want to speed up CPython by a factor of 5 over the next four releases.
> See the plan for how this can be done.
> Making CPython faster by this amount will require funding. Relying on the goodwill and spare time of the core developers is not sufficient.
This includes JIT and other awesome features for #python
https://github.com/markshannon/faster-cpython
We need this!
GitHub
GitHub - markshannon/faster-cpython: How to make CPython faster.
How to make CPython faster. Contribute to markshannon/faster-cpython development by creating an account on GitHub.
Implementation of a simple programming language for beginners.
The primary goal of Neon is to find out whether a useful programming language can avoid some of the common pitfalls that beginners frequently encounter in other languages. Some of these common errors avoided by design are:
- Floating point errors due to binary floating point
- Writing
- Null pointer exceptions
- Unintended empty loop with
- Forgetting to use the return value of a function
Personal opinion: very interesting take on this topic. I hope that we will have more beginner-friendly (or even beginner-only) languages in the future.
https://github.com/ghewgill/neon-lang
#cpp
The primary goal of Neon is to find out whether a useful programming language can avoid some of the common pitfalls that beginners frequently encounter in other languages. Some of these common errors avoided by design are:
- Floating point errors due to binary floating point
- Writing
if (x = 0) when if (x == 0) is intended- Null pointer exceptions
- Unintended empty loop with
while (condition);- Forgetting to use the return value of a function
Personal opinion: very interesting take on this topic. I hope that we will have more beginner-friendly (or even beginner-only) languages in the future.
https://github.com/ghewgill/neon-lang
#cpp
> When learning Object Oriented Design in a school setting, the discussion usually goes something like this:
> “This is a picture of a dog. What things can a dog do? Bark, eat, run, walk, these are its methods. What are some things that describe a dog? It is soft, brown, has 4 legs. These are its properties”
> “Purely behavioural code should be kept at a minimum at the boundaries of your domain layer, mostly to interface with the richer world of Nouns.”
> I like to refer to this object modelling advice as “Find the Nouns”, and it is wrong
This article describes a very different approach to OOP.
I wrote a similar article not so long ago: https://sobolevn.me/2019/03/enforcing-srp
> “This is a picture of a dog. What things can a dog do? Bark, eat, run, walk, these are its methods. What are some things that describe a dog? It is soft, brown, has 4 legs. These are its properties”
> “Purely behavioural code should be kept at a minimum at the boundaries of your domain layer, mostly to interface with the richer world of Nouns.”
> I like to refer to this object modelling advice as “Find the Nouns”, and it is wrong
This article describes a very different approach to OOP.
I wrote a similar article not so long ago: https://sobolevn.me/2019/03/enforcing-srp
An event-driven, portable runtime for building microservices on cloud and edge. Any language, any framework, anywhere.
Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to build resilient, stateless and stateful microservices that run on the cloud and edge and embraces the diversity of languages and developer frameworks.
Dapr codifies the best practices for building microservice applications into open, independent, building blocks that enable you to build portable applications with the language and framework of your choice. Each building block is independent and you can use one, some, or all of them in your application.
Dapr injects a side-car (container or process) to each compute unit. The side-car interacts with event triggers and communicates with the compute unit via standard HTTP or gRPC protocols. This enables Dapr to support all existing and future programming languages without requiring you to import frameworks or libraries.
Dapr offers built-in state management, reliable messaging (at least once delivery), triggers and bindings through standard HTTP verbs or gRPC interfaces. This allows you to write stateless, stateful and actor-like services following the same programming paradigm. You can freely choose consistency model, threading model and message delivery patterns.
Dapr runs natively on Kubernetes, as a self hosted binary on your machine, on an IoT device, or as a container that can be injected into any system, in the cloud or on-premises.
Dapr uses pluggable component state stores and message buses such as Redis as well as gRPC to offer a wide range of communication methods, including direct dapr-to-dapr using gRPC and async Pub-Sub with guaranteed delivery and at-least-once semantics.
Features:
- Event-driven Pub-Sub system with pluggable providers and at-least-once semantics
- Input and output bindings with pluggable providers
- State management with pluggable data stores
- Consistent service-to-service discovery and invocation
- Opt-in stateful models: Strong/Eventual consistency, First-write/Last-write wins
- Cross platform virtual actors
- Secrets management to retrieve secrets from secure key vaults
- Rate limiting
- Built-in Observability support
- Runs natively on Kubernetes using a dedicated Operator and CRDs
- Supports all programming languages via HTTP and gRPC
- Multi-Cloud, open components (bindings, pub-sub, state) from Azure, AWS, GCP
- Runs anywhere, as a process or containerized
- Lightweight (58MB binary, 4MB physical memory)
- Runs as a sidecar - removes the need for special SDKs or libraries
- Dedicated CLI - developer friendly experience with easy debugging
- Clients for Java, .NET Core, Go, Javascript, Python, Rust and C++
https://dapr.io/
#devops #go #k8s
Dapr is a portable, serverless, event-driven runtime that makes it easy for developers to build resilient, stateless and stateful microservices that run on the cloud and edge and embraces the diversity of languages and developer frameworks.
Dapr codifies the best practices for building microservice applications into open, independent, building blocks that enable you to build portable applications with the language and framework of your choice. Each building block is independent and you can use one, some, or all of them in your application.
Dapr injects a side-car (container or process) to each compute unit. The side-car interacts with event triggers and communicates with the compute unit via standard HTTP or gRPC protocols. This enables Dapr to support all existing and future programming languages without requiring you to import frameworks or libraries.
Dapr offers built-in state management, reliable messaging (at least once delivery), triggers and bindings through standard HTTP verbs or gRPC interfaces. This allows you to write stateless, stateful and actor-like services following the same programming paradigm. You can freely choose consistency model, threading model and message delivery patterns.
Dapr runs natively on Kubernetes, as a self hosted binary on your machine, on an IoT device, or as a container that can be injected into any system, in the cloud or on-premises.
Dapr uses pluggable component state stores and message buses such as Redis as well as gRPC to offer a wide range of communication methods, including direct dapr-to-dapr using gRPC and async Pub-Sub with guaranteed delivery and at-least-once semantics.
Features:
- Event-driven Pub-Sub system with pluggable providers and at-least-once semantics
- Input and output bindings with pluggable providers
- State management with pluggable data stores
- Consistent service-to-service discovery and invocation
- Opt-in stateful models: Strong/Eventual consistency, First-write/Last-write wins
- Cross platform virtual actors
- Secrets management to retrieve secrets from secure key vaults
- Rate limiting
- Built-in Observability support
- Runs natively on Kubernetes using a dedicated Operator and CRDs
- Supports all programming languages via HTTP and gRPC
- Multi-Cloud, open components (bindings, pub-sub, state) from Azure, AWS, GCP
- Runs anywhere, as a process or containerized
- Lightweight (58MB binary, 4MB physical memory)
- Runs as a sidecar - removes the need for special SDKs or libraries
- Dedicated CLI - developer friendly experience with easy debugging
- Clients for Java, .NET Core, Go, Javascript, Python, Rust and C++
https://dapr.io/
#devops #go #k8s