While I was in Orlando to present on Managing Android platform source with RTC at Innovate 2013 in June I took the opportunity to attend the UDeploy, now called UrbanCode Deploy, (I shorten it to UCD) workshop and came away suitably impressed.
Especially impressed by how easy and simple it is to understand, use and get started with. At it’s simplest here’s a short overview of what I needed to do to get a basic application deployment process automated.
1. Create a component and component process
Assuming I have a bunch of artifacts (files/folders) grouped together in some logical fashion, I can create a component using the “Create New Component” action. All I need to specify is a unique name for the component, what it’s source config type is – File System (Basic) in my case – and where the artifacts can be found on the file system.
This creates the component definition but does not suck in the artifacts from the file system. To get the component to be populated with the artifacts I go to the Versions tab for the component and use the “Import New Version” action specifying a version identifier to use. This imports the artifacts into UCD’s artifact repository, CodeStation.
Note that other Source Config Types can be set to automatically import new versions.
Next I define what is to be done to/with this component during a deployment. This can be as complex a task as required but it may be as simple as “copy the artifacts in the component to a location on the file system, having first cleaned that location out”. Navigating to the the new component’s Processes tab I create the following component deployment process. This is one of the features of UCD that caught my attention: being able to visualize the deployment process rather than have to wade through a textual bunch of steps.
2. Create an Application and application process
Then I define the application(s) that are composed of the components and for each application define the processes that typically invoke its component’s processes. Here is my simple application process. It just deploys (installs) the one component I have.
3. Define a Resource resolving to an agent
Resources represent deployment targets and typically have one or more UCD agent processes on them. I define a single resource representing my development server on which I already have an agent installed.
4. Define an environment for the application and map an agent to the component
An environment is the application’s mechanism for bringing together components with the agent that actually deploys them. I only need one environment “Development“. I add the previously defined Development resource to this environment and map the application’s component to the resource’s agent.
5. Invoke the application’s process on the environment
At this point I have all I need to carry out an actual deployment. So from the Development environment defined for the application I invoke (request) the application’s deployment process, which in turn will invoke the component’s deployment process.
Progress of the deployment process is displayed in the Application Process Request pane which provides links to detailed logs.
Pretty straightforward right? Of course as an enterprise class deployment automation framework, UCD has a ton of features that make it very very powerful. Here’s a list of useful links that provide a wealth of detail and learning resources for UrbanCode Deploy: