What do you use for Staging / Deployment Artifact Servers?

Question

I am thinking about writing my own release storage server and before I do this, I'd like to know what people use to see integration instead of create.

So what do you use to store your builds for internal access?

I'm looking for a web app that allows me to upload artifacts and then reference them by various tags so I can group them together by component or release vehicle. I also want access controls per build by readiness or promotion.

I define staging as placing built artifacts on a server for communities of users to access. The artifacts are usually zip files containing either applications or libraries + documentation. The user communities are developers, QA, and service delivery/operations. Basically, the creators, the checkers and external-users.

We release artifacts individually and as groups in a release vehicle (e.g., release 1.1 contains foo 1.0.1 and bar 1.0.7). Depending on the artifact, we may want to restrict access. Operations shouldn't be able to access pre-released builds and we may want to track who downloads a limited availability release.

So, I'm hoping to find a tool that does most of what I want with a good extensible design so I can add in what I don't have.

Any one know of a good tool for managing the builds post-build?

Examples might be:

• quickbuild/lunt build
• Team forge
• build forge
• Jira & confluence as a set
• sonatype nexus
• home grown
• SVN repository using branching to promote builds from dev->Qa->GA

Answer 1

Peter,

Since you're not getting many answers, I'll let you know about AnthillPro whose developer, Urbancode, I work for.

Ok, disclaimers out of the way, AnthillPro is designed to serve exactly the broad audience that you're discussing - dev, checkers, and operations. Compared to the tools you list, AnthillPro is something like a BuildForge (a key competitor of ours) or quick build with a tightly integrated artifact repository (like nexus). So the builds are run, and you can view the results of your builds - and the build artifacts - in a nice web ui. Users with correct permissions can run a secondary process like a deployment or test against prior builds - and the artifacts from the selected build.

The goal is to manage the entire build lifecycle from creation, through various testing tools and deployment environments out through release to production. It's not a big nasty suite, instead we integrate with tools like Subversion and Jira to make sure every release has a manifest of source and problem ticket changes.

Your release packages would map well to AnthillPro's built in dependency system. We often see customers create virtual projects that take little or no source code, but instead either relate or package components into a release bundle.

Where AnthillPro may fall short for you is that generally, we would allow operations to see pre-release builds. However, you could add rules that would immediately fail / block an attempted releaes by operations of any build not marked as "pre-release". AnthillPro's system of statuses allows the team to flag a build with custom markers like, "In QA" or "Approved for Release". Combined with rules about running workflows,that should give you the control you need. If some projects are particularly sensitive, you'd just use the role based security to lock those away.

Hope that gives you something to look into.

-- Eric

Answer 2

My options are

build automation systems like AntHill, QuickBuild, TeamForge, BuildForge

• file server
• source control server
• maven repository manager (nexus, archiva)

My goals are

• group build by multiple criteria (artifact type, release vehicle, stage/phase)
• promote build from dev -> qa -> released
• provide access control for dev builds, qa ready builds, production ready builds

I'm going to focus on either source control as file server (using svn) or maven repos manager as file server using nexus. The rational is as follows:

• minimize effort
• minimize cost
• use something I can easily extend when needed to (because I'm certain my requirements will shift).
• maven use is growing and will eventually be the dominant build technology here.

Thanks for the information.