This post will discuss why you need a private Nuget feed by listing some benefits.
So I have to be honest, I’m the kind of person that is always looking for a better way to do something. And it probably speaks volumes to my chosen career that I am that way. One of the reasons I’m so passionate about technology is that it on a foundational level supposed to change and improve our lives.
To that end, I’ve been having a lot of conversations lately around development and managing technical debt, sprawl, and just generally the ability to have more controls around major enterprise applications that are being built.
One of the biggest changes to coding, I would argue since the idea of Object-Oriented programming, has been the advent of the micro-service. This idea that I can build out a swarm of smaller services and leverage all these elements to do much larger tasks, and scale them independently has fundamentally changed how many of us look at Software Architecture and Solution development.
But with this big step forward, all too often, I see a big step backward as well.
And one of the ways this regression into bad habits happens is that I all to often see it become the “Wild west” of software development, and everyone runs off building individual micro-services, with no idea to operations or manageability. This ultimately leads to a myriad of services that are now very difficult to maintain.
For example, all services have several common components:
- Configuration Management
- Secret Management
- Monitoring / Alerting
- Exception handling
- Availability Checking
- Health probes endpoints
And if these elements are coordinated, then what can happen is that it becomes very difficult to maintain a solution because if you have 100 services in the application, you could potentially have 100 different ways configuration is managed. This is a nightmare to be honest. The good news is that they solved this problem, with npm and nuget!
One of the key benefits of leveraging a custom nuget server is that it allows you to gain the ability to have pre-made application components that then can be leveraged like lego blocks by developers to increase their productivity, so from their side, you can use these to get a jump on the new services they build.
Now most developers I know, love to reuse things, none of us got into this field to rewrite code for the hell of it.
Now if using the above, you create nuget packages around these types of operations (and more you will identify), and hook them up to their own CI/CD process that ends in an artifacts feed, we gain a couple of benefits:
- Developers stop reinventing the wheel: You gain the productivity gains of being able to plug-and-play with code. You basically get to say “I’m building a new service, and I need X, Y, and Z…”
- We get away from “It works on my machine” as all dependencies are bundled, and can get to a container that is more cleanly implemented.
- You gain more change control and management: By versioning changes to nuget packages, and leveraging pre-release packages appropriately, we can roll out changes to some services and easily look at all of our services and see which ones are consuming older packages. So ultimately, we can manage the updates of each service independently, but take the need to track that off the developer and onto a service.
- Make updates to shared code easier and an afterthought: Stop me if you heard this one before. You as a developer are performing updates to a service that leverages an older piece of shared code that someone discovered a bug with. You are working on their bug, and don’t think about the shared code that should be updated at the same time, it fell through the cracks. And when you finish, the new version of service is deployed with old shared code, and no one is the wiser. A change happens later to enforce something and it breaks service.” By leveraging nuget packages, it can become standard practice to say “I’m starting work on this service, select manage nuget packages and it shows me a list of packages with updates, I say update all.”
- You gain more ability to catch things earlier ahead of release preventing delays: It makes it a lot easier to coordinate the changes being made to common code when you use a nuget feed, and make it easier for developers to adjust. For example, If I’m working on Service A, and during our standup I find out that another member of my team has a pre-release of the nuget package I’m using, and both are going to prod around the same time. I can implement the pre-release, and make the changes before I get to a point of needing to integrate this at the end and pushing last minute changes.
There are some great posts that get into the specifics of this, and how to implement it, and those are: