Deployment Diagrams - UML

A deployment diagram shows the assignment of concrete software artifacts (such as executable files) to computational nodes (something with processing services). It shows the deployment of software elements to the physical architecture and the communication (usually on a network) between physical elements. Deployment diagrams are useful to communicate the physical or deployment architecture, for example, in the UP Software Architecture Document,

Figure 38.1A deployment diagram.

The basic element of a deployment diagram is a node, of two types:

  1. device node (or device) :- A physical (e.g., digital electronic) computing resource with processing and memory services to execute software, such as a typical computer or a mobile phone.

  2. execution environment node (EEN) :- This is a software computing resource that runs within an outer node (such as a computer) and which itself provides a service to host and execute other executable software elements. For example:

    • an operating system (OS) is software that hosts and executes programs
    • a virtual machine (VM, such as the Java or .NET VM) hosts and executes programs
    • a database engine (such as PostgreSQL) receives SQL program requests and executes them, and hosts / executes internal stored procedures (written in Java or a proprietary language)
    • a Web browser hosts and executes JavaScript, Java applets, Flash, and other executable technologies
    • a workflow engine
    • a servlet container or EJB container

As the UML specification suggests, many node types may show stereotypes, such as «server», «OS», «database», or «browser», but these are not official predefined UML stereotypes.

Note that a device node or EEN may contain another EEN. For example, a virtual machine within an OS within a computer.

A particular EEN can be implied, or not shown, or indicated informally with a UML property string; for example, {OS = Linux). For example, there may not be value in showing the OS EEN as an explicit node. Figure shows alternate styles, using the OS as an example.

The normal connection between nodes is a communication path, which may be labeled with the protocol. These usually indicate the network connections.

A node may contain and show an artifact - a concrete physical element, usually a file. This includes executables such as JARs, assemblies, .exe files, and scripts. It also includes data files such as XML, HTML, and so forth.

A deployment diagram usually shows an example set of instances (rather than classes). For example, an instance of a server computer running an instance of the Linux OS. Generally in the UML, concrete instances are shown with an underline under their name, and the absence of an underline signifies a class rather than an instance. Note that a major exception to this rule is instances in interaction diagrams - there, the names of things signifying instances in lifeline boxes are not underlined.

In any event, in deployment diagrams, you will usually see the objects with their name underlined, to indicate instances. However, the UML specification states that for deployment diagrams, the underlining may be omitted and assumed. Therefore, you can see examples in both styles.

All rights reserved © 2020 Wisdom IT Services India Pvt. Ltd Protection Status

UML Topics