Cora Iberkleid 🚢

/ciberkleid

Cora Iberkleid 🚢

Developer Advocate at Tanzu by Broadcom focused on Kubernetes and Spring related technologies.

User Avatar

Cora Iberkleid 🚢

2y ago

Understanding The Modern Monolith, With Spring Modulith
Cora Iberkleid 🚢

In the early 2000s, Service Oriented Architecture (SOA) popularized organizing code into distinct services mapped to business functions. It failed, however, to provide the necessary pragmatism for this lofty ideal.

A decade later, microservices offered pragmatism bordering on dogma: every service became its own repo and runtime process, spurring a new set of challenges intrinsic to highly distributed systems.

And now (thankfully!), Spring Modulith is here to offer a happy medium between the muddled monoliths of SOA and the overabundance of microservices. And—in contrast to the valiant but lackluster attempts of its predecessors—it provides the necessary framework to ensure that we get it right.

Enforcing Domain Driven Design

Spring Modulith provides an opinionated and fully implemented* set of rules to determine the architectural "correctness" of your code. It's opinions are based on Domain Driven Design (DDD), which focuses on crafting software to closely match the real-world domain.

Key Principles

  • Modular Organization: Each top-level package represents a functional module. Keep things tidy and focused.

  • Visibility Control: Expose only what's necessary. Elements for external use go in the module's base package; everything else belongs in sub-packages.

  • Event-Driven Communication: Foster clean communication between modules using Spring ApplicationEvents. Say goodbye to messy cross-module invocations.

  • Dependency Management: Cyclic dependencies are a no-go. Spring Modulith flags them, helping you maintain a healthy codebase.

How It Works

  • Integrating Spring Modulith into your Spring Boot application is a breeze. Just include the dependencies and run a quick check (from src/test/java...!):

    ApplicationModules.of(Application.class).verify();
  • This creates an in-memory representation of your code that is used to evaluate all of your modules (top-level packages) and any architecturally relevant elements within them, including Spring Beans, Services, Repositories, Event Listeners, Configuration Properties, Aggregate Roots, Events (published and consumed)...

Documentation and Testing

  • You can publish a visual snapshot of your architecture with UML or C4 diagrams, or generate a table-based overview called an Application Module Canvas (AMC).

  • You can also run integration tests on individual modules or subsets of modules to ensure a controlled and scalable codebase. This can help identify unintended dependencies on Beans from other modules and to be disciplines about mocking them.

Conclusion

This is the tip of the iceberg. The take-away is that if you're working with monoliths, Spring Modulith can help add some much needed structure and discipline into your code structure. If you're working with microservices, it gives you the choice to be more deliberate about the services that need to be coded, deployed and scaled independently, and to reduce code sprawl elsewhere.

Either way, Spring Modulith can teach us about good architectural practices and up our game in writing code that we can be proud of.

User Avatar

Cora Iberkleid 🚢

2y ago

The Single Most Important Strategy For Running Your Platform as a Product
Cora Iberkleid 🚢

If you're tackling the challenge of managing a cloud-native platform, the prevailing guidance is to "treat your platform as a product." Great advice, but what does it mean, and how do you know you're doing it right?

Understanding the Product Paradigm

Treating your platform as a product means approaching its development with a holistic mindset. Beyond streamlining operational routines, the product paradigm emphasizes delivering a cohesive and valuable experience for users. In the context of cloud native platforms, the primary users are typically developers.

The Game-Changing Strategy: Make it Optional

Perhaps the most crucial strategy for treating your platform as a product is to make its usage optional. When your platform is optional, it requires making it compelling enough for users to choose it willingly. This might seem like a minor detail, but its implications are huge.

User-Centric Design

Opting for optional platform usage puts user needs at the forefront. The platform engineering team shifts from focusing on routine operational tasks to understanding and meeting the distinctive requirements of platform consumers.

Cultural Transformation

The concept is simple, but achieving a seamless and user-centric experience demands a concerted effort, strategic planning, and continuous adaptation. The strategy of optionality will profoundly impact the culture of your platform engineering team to enable it to meet the demands of a winning platform.

It may not be easy, but it will be worthwhile!

User Avatar

Cora Iberkleid 🚢

2y ago

Build v. Buy: A Case of Market Maturity for Cloud Native Platforms
Cora Iberkleid 🚢

Achieving an end-to-end solution that encompasses the entire product lifecycle—from building and testing to securing, deploying, running, scaling, and monitoring, not to mention enhancing the developer experience—is an ever-evolving mission. IT departments, well-versed in crafting internal platforms, periodically reassess the status quo. A pivotal dilemma emerges: persist with the bespoke approach or transition to a commercial alternative?

In such situations, three litmus tests provide valuable insight.

1. Investment

Quantify the investment in your platform. Break down the dollars allocated for research, development, and ongoing maintenance, along with the talent committed to tackling these challenges. Get an honest view of the time, effort, money, and sacrifices involved.

2. Industry Dynamics

In emerging markets, like the early landscape of Kubernetes, in-house solutions often outshine commercial alternatives. However, in time, the innovation offered by commercial solutions surpasses what most IT departments can achieve. Remember, for vendors, platforms are not merely necessary plumbing—they are the bread and butter. At this innovation inflection point, you must decide if it's time to cut your losses.

3. Business Priorities

But, beware of shiny object syndrome. Fancy features may be tempting, but maintaining a clear vision of what truly matters is paramount. Focus on the capabilities that impact your business-critical outcomes.

A Litmus Test Of Market Maturity

Perhaps most interesting, however, is that beyond the build versus buy dilemma for any individual company, a general shift towards buying signifies a milestone in the market's maturity. This emphasizes the need for organizations to adapt to evolving landscapes.

In the domain of Cloud Native platforms, I believe that we've reached that milestone, and the inflection point indicates that, especially for larger organizations, the benefits of buying outweigh those of building.

The question is, what is your organization doing?

User Avatar

Cora Iberkleid 🚢

🍃Spring

2y ago

No More SSL Pitstops: Spring Boot Adds Hot Reloads For Keys & Certs
Cora Iberkleid 🚢

SSL keys and certificates serve as guardians of online security, protecting sensitive information and facilitating secure communication between applications. In a noble act of self-sacrifice, these keys and certs embrace expiration for the greater good of enhancing overall cybersecurity. Yet, they don't relinquish control without a fight.

SSL Pitstops

Picture a nail-biting Formula 1 race – a tire is reaching the end of its lifespan, risking chaos on the track. Much like our noble but very lazy guardians, this tire ain't gonna change itself. Our speedster is going to need a pitstop crew.

Similarly, traditional SSL certificate and key rotation necessitate a pitstop crew for applications. Inefficient handling can wreak havoc, causing downtime and frustrating users. These cybersecurity pitstop crews vary – manual labor involves restarting applications, external tools avoid app restarts but demand complex configuration, and proxies decouple SSL termination but require separate setup.

Crew Cuts

Enter Spring Boot 3.2, the new race car capable of changing its own tires without a pitstop crew. This new feature, hot reload, is a game-changer for developers and system administrators, providing a seamless solution to the SSL rotation challenge. No more halting operations or relying on external tools – the digital race can continue at full throttle. True to Spring Boot's style, it's also easy to configure.

In brief, the Spring Boot app loads keys & certs from given locations (per your configuration), and watches these locations for changes. When the files are changed (by an external process), the app will swap in the ones without restarting. Any new connections will use the new keys & certs.

Security Turboboost

This new capability not only ensures a more secure online presence but also maintains a smooth user experience. So, buckle up! The future of SSL management is here, and it's speeding ahead without looking back.

For details on setup, check out: https://spring.io/blog/2023/11/07/ssl-hot-reload-in-spring-boot-3-2-0

User Avatar

Cora Iberkleid 🚢

2y ago

Developers & Cybersecurity Teams: Friends or Foes?
Cora Iberkleid 🚢

In a recent chat, I was asked about the gaps I see in the way developers and cybersecurity teams approach bugs and vulnerabilities. This got me thinking...

Silo Whack-A-Mole

If I had a penny for every time I've heard the phrase "breaking down the silo," I'd be dining atop a private yacht under a starlit sky right now. Breaking down silos is a common goal in tech to improve collaboration and streamline processes, but it's no small feat to break down the silo between devs and cybersecurity.

Who's Flying The Plane?

If developers are the fearless pilots steering app-planes through the digital skies, cybersecurity are the air traffic controllers, ensuring a smooth flight for everyone. Each group operates from distinct cruising altitudes, with developers focused on their specific journey and cybersecurity overseeing the grand airspace. These differing perspectives on security risks, along with unique pressures and constraints, contribute to the gaps between developers and cybersecurity teams.

Mind The Gap

As we navigate collaboration in the tech skies, developers and cybersecurity teams may not always align in language and priorities. For example, they use different tooling to examine or resolve issues, so they're not always working with the same information. In addition, cybersecurity may prioritize an issue based on the potential impact on business operations or compliance, while developers may prioritize bug fixes based on project timelines. These differences can lead to important gaps in communication, whether it's developers not properly assessing the severity of a risk or communicating security concerns clearly, or cybersecurity not effectively conveying the level of concern or the possible implications of certain vulnerabilities.

Friendly Skies

If aviation can, so can we!

We may have a ways to go, but if nothing else, this post can serve as a reminder to foster a culture of collaboration, enablement, and shared responsibility for a holistic and proactive approach to software security. It's the key to keeping all passengers safe!

User Avatar

Cora Iberkleid 🚢

🍃Spring

2y ago

The Ultimate Local Dev Experience: Your Containers Start Themselves
Cora Iberkleid 🚢

Gone are the days of installing backends—databases, message buses, you name it—on our own machines. Docker containers made that obsolete, replacing each unique "experience" with a simple docker run.

Then, Docker Compose upped the game, replacing imperative docker run commands with a declarative configuration that was willed into existence with a single docker compose up. For those of us who remember the old days, this is pretty fantastic.

And now... I can hear Chandler Bing in my head asking, "Can it BE any easier?"

Spring Boot says, "Why, yes! Yes. It. Can."

Self-Sufficient Applications

As of Spring Boot 3.1, using either Docker Compose or Testcontainers, your Spring Boot application will start its own containers before kicking off the main application code. Boom.

Docker Compose, Hands Off

If you have a docker-compose.yml file already, this is a no-brainer. Add the new spring-boot-docker-compose starter to your list of dependencies and skip straight to app startup. Spring Boot will find the file and save you a terminal command.

Spring Boot and Testcontainers for Dev

Testcontainers, a long-time fave for starting containers for testing, can now be used for development, too. The docker-compose.yml is replaced by simple beans annotated as @ServiceConnection, and application control is handed from a Main class in the test package to the Main class in the main package after containers are started. One advantage of this approach is that ports are dynamically assigned to containers, thereby eliminating any risk or annoyance of port conflicts.

How Is This Even Possible?

Spring Boot did a little "abstraction magic" so that it could obtain connection info from different providers. This simplifies how Spring Boot feeds connection info to your app, and it enables different providers to "plug in" to Spring Boot. Enter Docker Compose and Testcontainers!

More than a little nostalgic, I can still hear Chandler. "Can it BE any easier?" For now, this is where we are. And it's pretty darn easy.

User Avatar

Cora Iberkleid 🚢

🍃Spring

2y ago

Low Code/No-Code API Gateway, with Spring Cloud Gateway
Cora Iberkleid 🚢

Spring's all about making software development easier, but Spring Cloud Gateway takes the cake. Without writing a smidge of code, you can achieve not only basic HTTP routing, but also sophisticated party tricks like weighted routing and rate limiting. Let's explore.

Gateways Are Super Important

A gateway sits between consumers (software or human) and your applications. The more apps you have (and with microservice architectures we tend to have a few), the more pain you'll feel without a gateway, but even with one or a few apps, the benefits are clear.

For developers, gateways simplify development by handling cross-cutting concerns. For operators, they are a central point for monitoring. For security teams, an opportunity to protect against threats and enforce policies. And for consumers, gateways provide a better experience through a friendly API, single point of access, and increased reliability.

The "No-Code" Experience

With Spring Cloud Gateway (SCG), you can certainly get dirty with Java. But for many cases, you don't have to. Many of the capabilities of SCG can simply be configured in your handy application.yml file. OK, it's not drag-and-drop, but YAML is a far cry from coding.

To whet your appetite, take a look at this example of consumer API control and weighted routing, which directs about half the traffic to one of two endpoints.

It doesn't get easier than this!

Hungry For More?

Try out the examples at https://github.com/ciberkleid/spring-cloud-gateway-sample or check out the docs at https://docs.spring.io/spring-cloud-gateway/reference/spring-cloud-gateway/configuring-route-predicate-factories-and-filter-factories.html.

User Avatar

Cora Iberkleid 🚢

🌊Kubernetes

2y ago

Pulling The Tablecloth Out From Under Your Docker Image (How to Safely Swap Out The OS)
Cora Iberkleid 🚢

Pulling a tablecloth out from under a set table without disturbing the dinnerware is so intimidating I would never even attempt it. I'm sure I'd shatter everything and have to start over with new porcelain and fresh wine glasses.

Dockerfile: Brute Force

Dockerfile is not so shy. Docker images are composed in layers. Imagine the OS is the tablecloth, the runtime is the dinner plate, and your application is the salad plate.

When Dockerfile changes the OS (base image), it ruthlessly throws away all the layers that had been carefully placed on top. Your expensive china shatters to pieces.

What's worse, there's no guarantee that it will be able to recreate the layers precisely. Depending on how your Dockerfile is written, the new china may not completely match. It would be more predictable and less risky not to disturb existing layers at all.

Buildpacks: Set It And Forget It

With Cloud Native Buildpacks, you set your proverbial table once and can rest easy that if the base image is updated, all other layers (certificates, runtime, app, metadata, etc) will remain untouched. This is called "rebasing."

Buildpacks have fine-grained control over image layers and can therefore manage changes more efficiently. For OS updates in particular, they take advantage of a contractual guarantee—known as Application Binary Interface (ABI)—between the base image and other layers that assures compatibility after a rebase.

Security Now

Dockerfile does not provide a mechanism to update all Dockerfiles that reference a base image with a known vulnerability. In contrast, Buildpacks deliver patches to all end users in one fell swoop, because the "engine" that churns your app source code into an image is distributed as a centralized, reusable resource (itself an OCI image). Add to that the fast and non-invasive way Buildpacks update the OS. It's a no-brainer that Cloud Native Buildpacks offer superior security and peace of mind.

You can bet that if I could use Buildpacks to swiftly pull out my tablecloth and keep my dinnerware intact, I'd be performing magic tricks in my dining room right now!

User Avatar

Cora Iberkleid 🚢

🍃Spring

2y ago

Thank You, Spring Boot
Cora Iberkleid 🚢

One April morning in 2013, Spring Boot was born. For a large majority of Java developers, the world has never been the same. Here are some of the reasons I, for one, am grateful for this revolutionary innovation in the arena of software development.

It Takes Courage To Be Opinionated (E.E. Cummings)

Spring Boot provides an opinionated approach to building software that includes automatic configuration for a broad number of use cases and integrations (batch, web, streams, cloud, security, data, and so on), including sensible, production-ready defaults for Day 2 requirements like metrics, health checks, and monitoring.

Simplicity Is The Ultimate Sophistication (Leonardo Da Vinci)

Spring Boot minimizes the amount of code and configuration needed by focusing on convention over configuration. Conventions comprise patterns and naming standards. If we all speak the same jargon and agree on a common set of assumptions, we'll communicate more expeditiously. Save the voluminous discourse for edge cases.

Spring Boot also makes dependency management a lot simpler by aggregating curated dependencies into "starters," grouped by function (e.g. batch, web, security, streams...). Add a starter to your list of dependencies and voilà, Spring Boot immediately enriches your application in the most sensible ways.

Change Is The Only Constant In Life (Heraclitus)

Spring Boot helps us stay on top of the exciting—and overwhelming—pace of innovations. With thoughtful solutions for distributed microservices, to default security, to incorporating the latest Java efficiencies (and so much more!), Spring Boot positions us for success.


In a word, THANKS, Spring Boot! You have made better & happier developers of all of us.

User Avatar

Cora Iberkleid 🚢

🌊Kubernetes

2y ago

Does This Docker Image Contain Peanuts?
Cora Iberkleid 🚢

I think every country around the world requires that packaged foods include a list of ingredients so that consumers can make informed decisions about whether or not to put said foods into their bodies.

For software, it's still a bit more wild west. Organizations need to vet software before deploying to production. The question is, where to get the list of ingredients?

Software Bill Of Materials (SBOM)

SBOMs are the ingredient lists for software. They can include component names, versions, licenses, dependencies, and origin. And since the gatekeepers (you at the supermarket or your automated Software Supply Chain at work) may speak different languages, they can be written in different formats (SPDX vs CycloneDX, for example).

You Get An SBOM, And You Get An SBOM, And YOU Get An SBOM!

Cloud Native Buildpacks generate SBOMs as part of the build, and they embed these files as a layer inside the resulting Docker image. You can try it for yourself on one of your apps:

pack build my-img --builder paketobuildpacks/builder:tiny

pack sbom download my-img; tree layers

This will produce detailed inventory files that your scanner of choice can use to sniff out any peanuts, thereby preventing hazardous reactions in production. Saved!

Conclusion

It's hard to say your production environment is secure and compliant if you don't know what's in it. Thankfully, if you build your container images using Cloud Native Buildpacks, you'll have the transparency you need to thoroughly inspect them before dropping them into your most precious environments.

User Avatar

Cora Iberkleid 🚢

2y ago

SOA Dreams, Microservices Delivers
Cora Iberkleid 🚢

I read an article today positioning Service Oriented Architecture (SOA) and Microservices as two architectural options, and the neutrality of the article surprised me, especially considering it was written a short year and a half ago.

Perhaps I'm oversimplifying, but I've always seen Microservices as an evolution of SOA, not an alternative. SOA had dreams. Big dreams! And Microservices made them possible.

SOA Dreams

Back in the '90s, developers realized that turning spaghetti into tortellini enabled better development practices and cleaner, more maintainable, and more reusable code.

The problem was that they could only do this in their own kitchen. In order to deliver the tortellini to the dining table, they had to mush all of them together—meat tortellini, cheese tortellini, potato tortellini—into a single, mushy ball so that they could be hoisted onto a big shared platter for everyone. In tech terms, monoliths were separated into services that were then bundled together into a single .ear file and deployed into a shared application server. Any potential benefits of separating services at runtime were promptly stunted.

Microservices: Livin' the Dream

Two things that still amaze me about microservices:

  1. They flipped the script. Rather than one app server for a bunch of tortellini, each tortellini was equipped with its own tiny, personal app server. Brilliant!

  2. They standardized. This opportunity was provided by the invention of Docker and container runtimes, all the way to Kubernetes. Tortellini matured into ravioli, all cut into the same beautiful shape and equipped with everything they needed on their journey to production—OS, runtime, app... all of it.

The dream of loosely coupled, composable services that can be deployed and scaled independently was now a reality not only for developers, but also for their operations counterparts. Everything became simpler, everyone became more agile, and this new reality has made way for new and bigger dreams.

Final Thoughts

SOA was more than simply breaking down monoliths, but I personally cannot separate SOA as an architecture from the technological limitations of its time because these limitations were also inputs into the ideas of SOA. Reevaluating SOA within the context of modern technology can provide value, but using the term SOA like it's the early 2000's, ignoring the broad and transformational impact of containerization on industry practices and innovations—from microservices to Kubernetes and beyond—eludes me.

User Avatar

Cora Iberkleid 🚢

🌊Kubernetes

2y ago

Buildpacks 101, For Dockerfilers
Cora Iberkleid 🚢

An intro to Cloud Native Buildpacks, for people who know Dockerfile.

Decent Dockerfile

You may know more about Dockerfile than I do, but as far as I can tell, this one here is not terrible. I've annotated some of the considerations that went into it.

Would I swear it's good enough for production? That no hacker will crack it? That I'll watch for base image patches and let everyone who copies this file know when I've changed it?

Heck no. Not today, not tomorrow, not ever. And that's a red flag.

Buildpacks Basics

Consider the following command:

pack build my-first-cnb-img --builder paketobuildpacks/builder:tiny

  • pack - The "platform." In this case a CLI for an experience similar to docker build...

  • builder - The "builder." An OCI image that contains everything else you need, including:

    • base images - As in a 2-stage Dockerfile (lines 1 and 11), your code will be processed on the builder and then the layers will be exported to a minimal run image.

    • buildpacks - The logic to process code into layers. Like 6-9 above, plus security and optimizations and other features, not just for Java, but also other languages.

    • lifecycle - The APIs for the platform to run Buildpacks on your code. It keeps the platforms and buildpacks decoupled, making it easier for the ecosystem to grow.

Reading Between the Lines

Without any effort and without taking on any responsibility to guarantee or maintain Dockerfiles for yourself or others, you can take advantage of a mature and sophisticated engine for producing secure, efficient, and well-organized OCI images, and you can be sure all applications using this process are accessing the same central, updated builders.

The Tip of The Iceberg

This is just the beginning! Keep an eye out for future posts where I'll dive into other benefits. If you can't wait, try the command pack help and play around with some of the options, including inspect, sbom, and rebase.

User Avatar

Cora Iberkleid 🚢

🍃Spring

2y ago

Four Ways: From Java Code To Docker Image
Cora Iberkleid 🚢

Option 1: Dockerfiles, since 2013

Dockerfiles enable you to DIY a script to add layers (OS, runtime, application...) into your container. This provides fantastic flexibility but also risk—it's on you to guarantee correctness, security, optimization, and OS/runtime updates. No pressure.

Option 2: Jib, since 2018

A Google project just for Java, this maven/gradle plugin adds compiled class files to a minimal base image, includes some optimizations for app startup & container rebuilds, and allows configuration per-app (via pom.xml, e.g.). Convenient for simple, Dockerfile and Docker daemon-free builds, but the extreme simplicity and focus on a single app introduces risk at scale (e.g. can you remember what cfg went into each pom.xml?).

Option 3: Cloud Native Buildpacks, since 2018

A collaboration between Heroku and Pivotal (now Broadcom), Buildpacks take source code and produce an OCI image in one simple step that accounts for security, governance, optimizations, and consistency across all applications. A common, shared builder image churns code into layers, guaranteeing all apps across your org are built & updated the same way.

Option 4: Spring Boot, since 2020

Spring Boot's maven/gradle plugins can produce not just JAR fies, but OCI images too (e.g. mvn spring-boot:build-image). Under the covers, they're actually using Option #3 above, with the OSS Paketo implementation of the Cloud Native Buildpacks project.

Recommendations

I don't know about you, but I'd pick Options 3 or 4 any day of the week for my Java apps!

User Avatar

Cora Iberkleid 🚢

🍃Spring

2y ago

My Cat Is 36 in Human Years. How Old Is My Spring App?
Cora Iberkleid 🚢

If you're asking yourself the same question, it probably means your Spring app is due for a health check. But despite the many Doctors—Syer, Pollack, De Volder—on the Spring team, or any of their equally qualified teammates, none have the bandwidth for house calls for all Spring apps around the world.

Lucky for us (and them!), as of this morning, there is a new (and free!) tool that you can use at your leisure and in the privacy of your home to determine just how healthy your Spring app is.

I decided to try it on the trusty spring-petclinic application.

A Doctor in the House!

As shown below, you can use your pom.xml file to produce a list of the springframework dependencies (works for Gradle, too) and upload the list to the new (and did I say free?) Spring Health Assessment website.

Here are the results for an old commit of spring-petclinic from September 2022, which upgraded the app to Spring Boot 2.7.3:

And then again on the latest branch...

The report relies on the NIST National Vulnerability Database and provides further detail on each library analyzed.

A Fountain of Youth

Sadly, no vet can make my cat any younger, but for our Spring apps, the Spring Health Assessment Report can give us the knowledge we need to keep our apps young and spry forever.

Try it out at https://tanzu.vmware.com/spring-health-assessment

User Avatar

Cora Iberkleid 🚢

🍃Spring

2y ago

My First "Aha!" Moment With Spring
Cora Iberkleid 🚢

In 2010, I was assigned the task of streamlining the transfer and routing of quality control data coming from various manufacturing plants for a large electronics vendor. I was given free reign on the implementation and I jumped at the opportunity to bypass heavyweight application servers in favor of simple standard Java processes. I had a ball writing a program that would later enable me to fully appreciate the brilliance of Spring Boot. But that's a story for another day. Today's story is brought to you by Spring Batch.

What's This Spring Thing

During the course of the project, a wise soul suggested we evaluate Spring Batch for a particular component. I was new to Spring at the time and very quickly found myself captivated by the Spring Batch Documentation, building a mental model and a whole new vocabulary for batch processing. Jobs that consisted of Steps that processed Items. ItemReaders and ItemWriters for specific sources and destinations, be they files, databases, or queues. Optimization strategies using multi-threading, parallel processing and/or handling Chunks of lines at a time.

In short, the first thing I learned from Spring had nothing to do with Spring or with Java. It was simply best practices for general batch processing and a common vocabulary that I could use to communicate with my team and our stakeholders. This was gold.

Naturally, the words and concepts and strategies mapped to objects and APIs and configuration parameters in Spring Batch, but the most impactful takeaway for me was that Spring was a definition and a codification of best practices.

Spring IS Best Practices

If you want to know what the best practices are for any number of use cases—batch processing, stream processing, security, system integration, containerization, and more—Spring is not just your practical solution. It is your guide and teacher, and it will help you establish a common language, mental model, and understanding across your organization.

User Avatar

Cora Iberkleid 🚢

2y ago

Imperfection is the New Perfect
Cora Iberkleid 🚢

About 2 years ago I signed up for Dickie Bush & Nicolas Cole's cohort-based course, Ship 30 for 30, which focuses on building a daily writing & publishing habit. I managed through nearly half of the program before I lost steam, but today is the day I try again!

Why I Failed

One of the first lessons of the program is the difference between traditional and digital writing. In brief, the time invested into each publication is shorter for digital writing, which aspires to frequent posts. To achieve this trade-off of time for frequency, something's gotta give, and so one of the key teachings of the program is to relax your (in this case, my) preoccupation with perfection (gasp!). In my first attempt at Ship 30 for 30, I failed miserably in this regard. This is not to say my posts were perfect, but rather that my preoccupation over trying to make them perfect was time-intensive, counter-productive, and draining.

Perfect is the Enemy of Good Enough

I first received this piece of advice back in 2010, so it's about time I apply it. Join me on this adventure of good enough insights and explorations of techy topics in the world of Cloud Native Applications and Platforms, including development and deployment practices using Spring, the Kubernetes ecosystem, and anything else that pops up on my radar.

For today, my commitment to success will be to simply hit PUBLISH and move on, for tomorrow will be another perfectly imperfect day.

User Avatar

Cora Iberkleid 🚢

🌊Kubernetes

4y ago

My first act of heroism as a student computer lab assistant in the late 90s was unjamming a printer so that a frenzied PhD candidate could hand in their thesis. My second was replacing the magenta ink cartridge. I'd hoped to learn about computers; instead, I got suckered into printer maintenance.

Print jobs rely on the printer to provide everything necessary. Sometimes they require highly curated machines with fancy paper and staples. It takes significant effort to make sure each printer is always up to the task, and any setback can delay all jobs stubbornly lining up at the same destination. No wonder there were never more than a handful of printers in each lab.

If only we could package a tiny printer with sufficient ink and paper (and staples!) into each print job.

Then I would just need to plug the job into an electrical outlet. I could even copy the package and get the job done in half the time! No more babysitting printers.

We've been managing applications and environments in the same cumbersome way as print jobs and printers for decades. A successful deployment is the tenuous result of careful coordination between dev and ops to make sure the target environment has the proper runtime, libraries, configuration and resources needed for a particular application. It's a thankless job that must be repeated every time there is a change.

If only we could package a lightweight runtime and other necessary dependencies along with the application. Then we would just need to drop that package (or many copies of it) into an unfussy virtual machine. And by unfussy, I mean liberating.

Good news: containerization is the act of packaging all dependencies with an application using a standard format.

Containerization breaks the bondage between dev and ops and empowers each to reach a higher level of self-determination.

It sounds dramatic, but the impact of containerization has been exactly that. Development teams can take ownership of every aspect of their application and provide greater assurance that things will work as intended. Operations can use a simple common blueprint for all virtual machines and scale up and down as needed. By agreeing on a few simple packaging standards, dev and ops can clearly define the terms of interoperability such as exposing input ports and capturing log output.

Containerization is the gateway to growth.

With containerization, we can take a step back and manage our applications and environments in cleaner, more streamlined ways that enable much greater repeatability, resilience, and scale.

Can your print job do that?