This page is about the package process, and the types of packages you can create and deploy in Appian. Creating packages is a part of the deployment process, and should be taken into consideration while you are building applications to ensure that your changes will be deployed successfully.
For an overview about the deployment process, see Deploy Applications.
For more instructions on how to deploy your packages, see Deploy Packages to Target Environments.
A package is a collection of Appian application changes that a developer can deploy to another environment. Preparing a package is an important step in the deployment process and involves understanding what changes you need to deploy and how these changes will affect your target environment.
There are three different types of packages that you can deploy in Appian. In most cases, your packages will contain application objects, but can also include environment-specific information, such as import customization files or database scripts.
Applications contain a set of objects that make up a business solution. Applications should be used to introduce a new set of objects that do not exist in the target environment.
Patches contain new or updated objects, which a developer deploys when introducing an update to an existing application in the target environment. Patches are helpful for deploying bug fixes or enhancements.
Administration Console Settings contain updates to your Administration settings, such as site branding or third-party credentials in the target environment.
Your package may include dependencies that are required to successfully deploy updates to your application. Import customization files and database scripts are common dependencies that can be packaged with applications or patches. Your package may also rely on plug-ins or other dependencies that must be deployed before you start a package deployment. Depending on the type of changes you are making to the target environment, your list of dependencies and how you deploy them will vary.
There are two ways you can create packages in Appian: using compare and deploy to automatically identify changed objects or assembling your changes manually. To make your deployment process more efficient, compare and deploy is the recommended approach. Compare and deploy allows you to compare objects across environments, bundle database scripts and import customization files with your package, and inspect your objects before directly deploying your package to the target environment.
You must add environments to your infrastructure to use compare and deploy.
When deploying changes to a higher environment, such as a test environment, your packaging process should generally follow these steps:
Make sure that all necessary objects are in your application by running missing precedents. Both methods of creating packages start with the objects in an application. It is also a best practice to review the security summary and make sure all your objects have the appropriate security set before beginning the packaging process.
Comparing objects across environments allows you to review changes as you're packaging them and confirm that you are deploying the correct changes to the target environment. Comparing objects during package preparation is only available if you have added environments to your infrastructure.
If you manually create and export your package, you will have an opportunity to compare objects by inspecting your package upon manual import in the target environment.
Object comparison statuses are available when you compare objects across environments or inspect packages before import. These statuses are helpful for understanding how your objects differ between a source and target environment, as well as how they will be handled during deployment. You should use the statuses to confirm that the correct objects are in your package and detect any conflicts before continuing with a deployment.
|Status||Object Exists in Target Environment||Object Will Be Imported|
If you need to force an import for objects with a Not Changed status, add the
FORCE_UPDATE import-specific setting to your import customization file. See Managing Import Customization Files for more information on when and how to force an update.
Conflicts may occur when an object is modified in the target environment and modified separately in the source environment. Objects with the status of Conflict Detected will be displayed when comparing objects across environments or when inspecting a package before manual import. This status is helpful when deploying between multiple development environments. When you see this status, you should pause your deployment and proceed carefully since there is a chance of overwriting someone's work.
When you encounter unexpected conflicts you can further investigate as follows:
After creating your package, it is a best practice to inspect the objects before deployment. This ensures that no unexpected changes have been made to the target environment and detects potential conflicts or import errors early.
Compare and deploy automatically inspects your package after you finish preparing it. If you do not have environments added to your infrastructure, you can also inspect your package before import in the target environment.
The inspection results summarize which objects in your package have problems or warnings, how many will be created or updated by import, and how many will be skipped. When run in the target environment on a manually exported package, this summary also includes detailed information about the status of each object in your package and when they were last modified in the target environment.
Inspect only applies to Appian objects and the import customization file. Database scripts and plug-ins should be reviewed separately.
During deployment, the definition of each object in your package is exported from the source environment into an XML file. Appian bundles these XML files into a zip file, which is used to move the objects to the target environment.
Deploying a package is the last step in your packaging process. With compare and deploy, you can let Appian send your package to the target environment, as long as the target is configured to allow direct deployments. Alternately, you can download the package zip file and deploy it yourself by logging in to the target environment and manually importing it.
Information about related objects is preserved across the deployments. In most cases, the related objects themselves are not automatically exported. They must be explicitly added as objects within the package, or already present in the target environment. The application view allows you to check your application for missing precedents and add them to the application.
For instructions on how to deploy packages, see this page.
For more information about object-specific rules that apply to deployments, see this page.
On This Page