Official Plugins


Cloudify Plugins are Python packages that do the work of communicating with external systems. Primarily:

Infrastructure Plugins
Infrastructure Plugins
Configuration Plugins
Configuration Plugins

For example:


Blueprints use the Cloudify DSL to model an application. The model, or node_templates section, describes a topology which includes: * Node Templates * Relationships between node templates.

Workflows actualize the topology by defining the order of operations that will be performed. For example, the built-in Install Workflow calls, among other things, the create, configure, and start operations defined for a particular node type.

Plugins contain the Python code that each workflow operation calls.


In your blueprint, use the Import statement to import plugins, for example:

  - plugin: cloudify-azure-plugin

You can then map node template and relationship operations to plugin code, or if your plugin’s plugin.yaml has custom node types, these operations may already be mapped for you.

Example Blueprint with REST Call

The following example illustrates configuration step. In it, we create a user via some REST API.

In the blueprint, we define the lifecycle steps, along with the inputs for the plugin operation:

Let’s break down each section:

Now, let’s talk about our node_template:


This is the template file, which contains a list of requests. We define the path, the payload, and define the expected responses.

 # create user post
  - path: /posts/{{POST_ID}}
    method: PUT
      Content-type: application/json
      title: '{{ USERNAME }}'
      body: '{{ WEBSITE }}'
      userId: '{{ USER_ID }}'
    response_format: json
    recoverable_codes: [400]
      - ['id', '{{POST_ID}}']

Only one request is defined here, but you can define bunch requests as well as successful and failure responses.

For more information on modeling REST request sequences, see the REST Plugin.

Example Blueprint with Example Script

A another way to understand using Cloudify plugins is to use Cloudify with existing scripts.

For example, let’s say that you have a BASH script like this:


# myblueprint/scripts/
ctx logger info "Hello World"

All this script does right now is log a “Hello World” message message to Cloudify. However, you can put just about any valid BASH script here.

To run the following, you will need the following for a real VM:

Let’s review: * In the properties, we define the method for installing and configuring a Cloudify Agent on the VM. We provide the IP and authentication information. * We define the start operation as the execution of our script from above.

For more information, see the Script Plugin.

Example Blueprint with Blueprint Mapped Operations

The following example describes configuring one or more hosts with Ansible.

Just like last example, you will need the following for a real VM:

In this blueprint, we don’t define any properties. Instead, we map everything as an operation.

For more information, see the Ansible Plugin.

Example Blueprint with Custom Node Types

The following example describes the creation of a connected AWS EC2 Internet Gateway and VPC. The cloudify-aws-plugin’s plugin.yaml already defines the node types and, and maps their lifecycle operations to plugin tasks.

You will need the following secrets: * aws_access_key_id: The AWS Access Key. * aws_secret_access_key: The AWS Secret Key.

You will also need to provide the following inputs: * region_name: The AWS region name.

tosca_definitions_version: cloudify_dsl_1_3
  - plugin:cloudify-aws-plugin
    type: string
  _: &client_config
    aws_access_key_id: { get_secret: aws_access_key_id }
    aws_secret_access_key: { get_secret: aws_secret_access_key }
    region_name: { get_input: region_name }
      client_config: *client_config
    - type: cloudify.relationships.connected_to
      target: vpc
        CidrBlock: { get_input: vpc_cidr }
      client_config: *client_config

Let’s review:

We have the following nodes: * internet_gateway: This is an internet gateway. We use a cloudify.relationships.connected_to relationship to define dependency on vpc. * vpc: This is a VPC.

Properties: * We provide to both resources their configuration in the resource_config property. * Authentication is defined in the client_config property.

For more information, see the AWS Plugin.


Cloudify plugins are distributed as Wagons format. Wagons are archives of Python Wheels. The latest official Cloudify Plugins are available for download at Plugins Download.


You may upload a plugin to your Cloudify Manager via either the UI or the CLI:


See our community Contribution Guide.

Further Reading

For more information on creating your own plugin, see creating your own plugin. For a plugin template, see plugin template.

For information on packaging a plugin in wagon format, see creating wagons.

For an overview on working with CM systems, see Configuration Management.

For information on working with Docker and other container systems, see Containers.