jib

We use jib at work (https://github.com/GoogleContainerTools/jib) which also skips the Dockerfile and builds an image for a Java project directly. This certainly looks like a much nicer experience than docker build, especially given that there can be a cache hit after a cache miss.

Yeah this would be great if it had a feature like jib (https://github.com/GoogleContainerTools/jib) where it just natively packages into a container. It seems like it should have all the information it needs to work, as long as you can override the base image.

Hard to beat jib (https://github.com/GoogleContainerTools/jib/tree/master/jib-...) for minimal Java OCI containers.

Having the author do this for a service written in Go is a mistake. Your first address for containerizing Go services should be ko: https://ko.build/ , and similar solutions like Jib in the Java ecosystem: https://github.com/GoogleContainerTools/jib . No need to require everyone to install something heavy like Nix, no need for privileged containers in CI to connect to a Docker daemon so that actual commands can be executed to determine filesystem contents, just the absolute bare minimum of a manifest defining a base layer + the compiled artifacts copied into the tarball at the correct positions. More languages should support this kind of model - when you see that pnpm's recipe (https://pnpm.io/docker), ultimately, is to pick a pre-existing node base image, then copy artifacts in and set some manifest settings, there's really no technical

If you have an option to containerize the app, Jib may be what you are looking for. Plugs into Maven, and the same source/content always generates the same image - https://github.com/GoogleContainerTools/jib

For Java, JIB on distroless works pretty well. It's small, fast and secure. - https://github.com/GoogleContainerTools/jib - https://github.com/GoogleContainerTools/distroless

We use Google Jib with Gradle (https://github.com/GoogleContainerTools/jib) and love it. It does some slight optimisations (just use the classes rather than jars) and removes some decision making about where files are laid out. It also builds into the Gradle lifecycle neatly. I don't need a separate tool for building images. I'm sure writing Maven xml wouldn't be fun though!

Use jib (java image builder) with maven or gradle and it will build an image with distroless-java plus your app: https://github.com/GoogleContainerTools/jib https://github.com/GoogleContainerTools/distroless/blob/mast...

https://github.com/GoogleContainerTools/jib#what-is-jib > What is Jib? > Jib builds optimized Docker and OCI images for your Java applications Funny. Here I thought you could just build and deploy a jar if you were committed to writing Java... I suppose it does make sense that "all things come to docker/containers", though. Allowing both golang and Java services to be deployed in the same manner.

This is what I think is the most practical approach. Pinning down ALL your dependencies to the exact version is much harder than it sounds. What you’re describing sound like the way Jib [1] does it. The pictures in this [2] blog post help visualize it. The reason I like the approach you describe is because it keeps things simpler at the start of a project and consistent across most projects. I also think it makes sense to have those support containers build on a schedule. For example, you build your build/CI container weekly and that’s the CI container for the week. On demand project builds use that CI container which has all dependencies, etc. baked in. It would be nice if CI systems would let me explicitly tag builds as (non)reproducible. 1. https://github.com/GoogleContainerTools/jib 2. https://phauer.com/2019/no-fat-jar-in-docker

For Java you can use jib from google https://github.com/GoogleContainerTools/jib

The system you describe seems close to Jib [1] or Nixery [2], which are dependency-aware tools built on top of Docker. I think neither they nor the prototype you've described could be as distro/language-agnostic as Docker and ostree/flatpack are. Debian could offer something like Nixery, any distro could, but then it wouldn't be a cross-distro solution. I personally like appimage, but I don't mind using flatpack because it is so similar to Docker and is also supported on most major distros. Distro repositories aren't going anywhere, and I think flatpack strikes the right balance for users and developers. [1] https://github.com/GoogleContainerTools/jib [2] https://github.com/google/nixery

We haven't used Spring MVC since 2015, all our services are running Spring Boot because it is the most mature solution on the market to create the webservice layer. Our Spring apps are then containerized and optimized with jib[1]. Our frontend is built on React Hooks + TypeScript, fully SPA. All the work nowadays in our company is focused on data engineering, by that I mean: databases, parsers, managing the data pipelines, orchestration, Python for creating the models and Java for inference in production, our teams consist of data scientists that are using Python and software engineers that are using Java and TypeScript. I don't understand why people consider Spring to be overengineered. We find it very productive, time to market is huge and we can focus on other parts of development instead of reinventing the wheel. We are also consideri

One thing they don't talk about is using non-docker tools to build images. e.g. nix: http://lethalman.blogspot.com/2016/04/cheap-docker-images-wi... or jib: https://github.com/GoogleContainerTools/jib These may not fit every use case, but they can minimize the size of the image by making really precisely defined containers.