kylequest
├── bin
│ └── sbx
├── libexec
│ ├── containerd-shim-nerdbox-v1 <- Nerbox integration for ContainerD
│ ├── mkfs.erofs
│ ├── mkfs.ext4
│ ├── nerdbox-kernel-arm64
│ └── nerdbox-rootfs-arm64.erofs
More info about Nerdbox is here https://github.com/containerd/nerdbox
I'll post the whole thing in a Github repo too at some point, but it's taking a while to prettify the code, so it looks more natural :-)
There are a number of web/SaaS based vulnerability scanners out there actually :) Snyk's SaaS does it, for example. Free to sign up, free to use. My company's SaaS also provides container scanning with Grype and Trivy. There was another free web-based tool I found a while ago too (forgot the name... will look for it).
I'm the CTO/founder. I also created SlimToolkit (aka DockerSlim), which recently became a CNCF Sandbox project. If you have a background and passion for container internals, cloud native technology and security this might be an interesting role for you. I'm looking for an engineer (the exact title depends on your background/experience) to join the CTO Innovation Office team to work on advanced research projects and experiments. There'll be AI related experiments too :-)
If you think it's a good match for you and you want to learn more email me: [email protected]
The post also doesn't mention SlimToolkit (aka DockerSlim), which is now a CNCF Sandbox project. It represents another major way to create minimal container images.
I'm the founder and CTO at Slim.AI. I created DockerSlim as a hackathon project and it turned into a journey to help devs building containerized cloud-native apps. We are still early stage, but we are fortunate enough to have 40M+ to support our mission.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Serverless/Lambda and containers. More about us and the role on our eng github page ( https://github.com/slim-ai/engineering/blob/master/roles/bac... ).
We don't do Leetcode or the usual trivia-based puzzles and whiteboarding interviews. We customize the interview process based on the candidates and their background to make sure we get to learn as much possible and to see how working together can be mutually beneficial.
Our Engineering Principles:
* We use what we build.
* We share a common cloud-native mindset and a platform thinking DNA.
* We create stage appropriate designs that can evolve and that can be thrown away when necessary.
* We optimize for evolvable architecture building an extensible and composable system with disposable components using an API first approach.
* We optimize our designs for people first and machines second.
* We care about the entire system we are building considering the needs of our teammates and the impact of the design decisions we make.
* We learn together.
* We share knowledge and give back to the tech community.
* We have a written down and transparent culture that enables our remote first asynchronous approach to engineering.
* We have a lightweight engineering process based on trust, self-alignment and visibility.
Email me at [email protected] if you'd like to learn more.
distroless is picking up a lot of interest especially with its recent uptick in its adoption in the kubernetes community.
One thing I'd like to mention right away is that docker-slim doesn't do function level code elimination and that simplifies what it needs to do in a significant way.
I'm the founder and CTO at Slim.AI. I created DockerSlim as a hackathon project and it turned into a journey to redefine how DevOps is done for devs building cloudnative apps. We are still early stage, but we are fortunate enough to have 40M+ to support our mission.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Serverless/Lambda and containers. More about us and the role on our eng github page ( https://github.com/slim-ai/engineering ).
Our Interview Process:
We don't do Leetcode or the usual trivia-based puzzles and whiteboarding interviews. We customize the interview process based on the candidates and their background to make sure we get to learn as much possible and to see how working together can be mutually beneficial.
Our Engineering Principles:
* We use what we build.
* We share a common cloud-native mindset and a platform thinking DNA.
* We create stage appropriate designs that can evolve and that can be thrown away when necessary.
* We optimize for evolvable architecture building an extensible and composable system with disposable components using an API first approach.
* We optimize our designs for people first and machines second.
* We care about the entire system we are building considering the needs of our teammates and the impact of the design decisions we make.
* We learn together.
* We share knowledge and give back to the tech community.
* We have a written down and transparent culture that enables our remote first asynchronous approach to engineering.
* We have a lightweight engineering process based on trust, self-alignment and visibility.
Email me at [email protected] if you'd like to learn more.
I'm the founder and CTO at Slim.AI. I created DockerSlim as a hackathon project and it turned into a journey to redefine how DevOps is done for devs building cloudnative apps. We are still early stage, but we are fortunate enough to have 40M+ to support our mission.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Serverless/Lambda and containers. More about us and the role on our eng github page ( https://github.com/slim-ai/engineering ).
Our Interview Process:
We don't do Leetcode or the usual trivia-based puzzles and whiteboarding interviews. We customize the interview process based on the candidates and their background to make sure we get to learn as much possible and to see how working together can be mutually beneficial.
Our Engineering Principles:
* We use what we build.
* We share a common cloud-native mindset and a platform thinking DNA.
* We create stage appropriate designs that can evolve and that can be thrown away when necessary.
* We optimize for evolvable architecture building an extensible and composable system with disposable components using an API first approach.
* We optimize our designs for people first and machines second.
* We care about the entire system we are building considering the needs of our teammates and the impact of the design decisions we make.
* We learn together.
* We share knowledge and give back to the tech community.
* We have a written down and transparent culture that enables our remote first asynchronous approach to engineering.
* We have a lightweight engineering process based on trust, self-alignment and visibility.
Email me at [email protected] if you'd like to learn more.
I'm the founder and CTO at Slim.AI. I created DockerSlim as a hackathon project and it turned into a journey to redefine how DevOps is done for devs building cloudnative apps. We are still early stage, but we are fortunate enough to have 40M+ to support our mission.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Node.js Serverless/Lambda and containers. We have technical writer, frontend, backend and fullstack roles ( https://github.com/slim-ai/engineering ).
Our Interview Process:
We don't do Leetcode or the usual trivia-based puzzles and whiteboarding interviews. We customize the interview process based on the candidates and their background to make sure we get to learn as much possible and to see how working together can be mutually beneficial.
Our Engineering Principles:
* We use what we build.
* We share a common cloud-native mindset and a platform thinking DNA.
* We create stage appropriate designs that can evolve and that can be thrown away when necessary.
* We optimize for evolvable architecture building an extensible and composable system with disposable components using an API first approach.
* We optimize our designs for people first and machines second.
* We care about the entire system we are building considering the needs of our teammates and the impact of the design decisions we make.
* We learn together.
* We share knowledge and give back to the tech community.
* We have a written down and transparent culture that enables our remote first asynchronous approach to engineering.
* We have a lightweight engineering process based on trust, self-alignment and visibility.
Email me at [email protected] if you'd like to learn more.
P.S.
Take a look at DockerSlim ( https://github.com/docker-slim/docker-slim ) if you are interested in working on the open source project that powers our SaaS.
The recent set of the engine enhancements reduce the need for the explicit include flags. Also new application-specific include capabilities are wip (already added a number of new flags for node.js, next.js and nuxt.js applications).
I'm the founder and CTO at Slim.AI. I created DockerSlim as a hackathon project and it turned into a journey to redefine how DevOps is done for devs building cloudnative apps. We are still early stage, but we are fortunate enough to have 40M+ to support our mission.
Right now we are focusing on simplifying and accelerating the containerized app delivery (it's too hard, too complicated and with too much manual work). We are about to transition to the next phase and we are expanding our engineering team.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Node.js Serverless/Lambda and containers. We have technical writer, frontend, backend and fullstack roles ( https://github.com/slim-ai/engineering ).
Our engineering principles:
* We use what we build.
* We share a common cloud-native mindset and a platform thinking DNA.
* We create stage appropriate designs that can evolve and that can be thrown away when necessary.
* We optimize for evolvable architecture building an extensible and composable system with disposable components using an API first approach.
* We optimize our designs for people first and machines second.
* We care about the entire system we are building considering the needs of our teammates and the impact of the design decisions we make.
* We learn together.
* We share knowledge and give back to the tech community.
* We have a written down and transparent culture that enables our remote first asynchronous approach to engineering.
* We have a lightweight engineering process based on trust, self-alignment and visibility.
Email me at [email protected] if you'd like to learn more.
I'm the founder and CTO at Slim.AI. I created DockerSlim as a hackathon project and it turned into a journey to redefine how DevOps is done for devs building cloudnative apps. We are still early stage, but we are fortunate enough to have 40M+ to support our mission.
Right now we are focusing on simplifying and accelerating the containerized app delivery (it's too hard, too complicated and with too much manual work). We are about to transition to the next phase and we are expanding our engineering team.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Node.js Serverless/Lambda and containers. We have technical writer, frontend, backend and fullstack roles ( https://github.com/slim-ai/engineering ).
Our engineering principles:
* We use what we build.
* We share a common cloud-native mindset and a platform thinking DNA.
* We create stage appropriate designs that can evolve and that can be thrown away when necessary.
* We optimize for evolvable architecture building an extensible and composable system with disposable components using an API first approach.
* We optimize our designs for people first and machines second.
* We care about the entire system we are building considering the needs of our teammates and the impact of the design decisions we make.
* We learn together.
* We share knowledge and give back to the tech community.
* We have a written down and transparent culture that enables our remote first asynchronous approach to engineering.
* We have a lightweight engineering process based on trust, self-alignment and visibility.
Email me at [email protected] if you'd like to learn more.
P.S.
Take a look at DockerSlim ( https://github.com/docker-slim/docker-slim ) if you are interested in working on the open source project that powers our SaaS.
I'm the founder and CTO at Slim.AI. We are a well funded seed stage startup (9M+) in the developer tooling space. Our mission is to simplify and accelerate the containerized app delivery (it's too hard, too complicated and with too much manual work). We are about to transition to the next phase and we are expanding our engineering team.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Node.js Serverless/Lambda and containers. We have frontend, backend and fullstack roles ( https://github.com/slim-ai/engineering ).
Our engineering principles:
* We use what we build.
* We share a common cloud-native mindset and a platform thinking DNA.
* We create stage appropriate designs that can evolve and that can be thrown away when necessary.
* We optimize for evolvable architecture building an extensible and composable system with disposable components using an API first approach.
* We optimize our designs for people first and machines second.
* We care about the entire system we are building considering the needs of our teammates and the impact of the design decisions we make.
* We learn together.
* We share knowledge and give back to the tech community.
* We have a written down and transparent culture that enables our remote first asynchronous approach to engineering.
* We have a lightweight engineering process based on trust, self-alignment and visibility.
Email me at [email protected] if you'd like to learn more.
P.S.
Take a look at DockerSlim ( https://github.com/docker-slim/docker-slim ) if you are interested in working on the open source project that powers our SaaS.
Also videos from eBPF Day KubeCon 2021: https://www.youtube.com/playlist?list=PLj6h78yzYM2Pm5nF_GmNQ...
By the way, have you looked at the examples? https://github.com/docker-slim/examples Wonder which example is close enough to what you have.
Depending on the command you choose (e.g., "build" or "xray") it's doing different things. With "xray" it's all static analysis where it saves the images and then it analyses it internals. With "build" it performs static and dynamic analysis where it creates a temporary instance of your container. By default, it assumes it's a server app and it'll try to probe your server app when it's running.
We are a well funded seed stage startup (9M+) in the developer tooling space on a mission to redefine how DevOps is done for containerized apps (it's too hard, too complicated and with too much manual work). We are about to transition to the next phase and we are expanding our engineering team.
Our engineering team is the innovation engine for our product because we are building a solution to solve our own problems creating and running containerized cloud-native applications.
We use Golang, Node.js Serverless/Lambda and containers. Take a look at the backend ( https://github.com/slim-ai/engineering/blob/master/roles/bac... ) and fullstack ( https://github.com/slim-ai/engineering/blob/master/roles/ful... ) roles and our engineering principles to see if the role and how we do engineering looks interesting to you ( https://github.com/slim-ai/engineering#engineering-principle... ).
Email me at [email protected] if you'd like to learn more.
P.S.
And take a look at DockerSlim ( https://github.com/docker-slim/docker-slim ) if you are interested in working on the open source project that powers our SaaS.