1. Component and Deployment Diagrams
Sources:
Agile Modeling
IBM’s Rational Library

2. Summary Slide What is a Component Diagram
Component Diagram Example in UML 1.4
Component Diagram Example in UML 2
Basic Notation Used in Component Diagrams
Modeling a Component's Interfaces
Interfaces and Ports
Beyond the Basics
What is a Deployment Diagram
Deployment Diagram Example
UML Deployment Diagram Example
Concise UML 2 Deployment Diagram
Network Diagrams

3. What is a Component Diagram
The component diagram's main purpose is to show the structural relationships between the components of a system. [IBM Rational Libraries]
UML component diagrams are great for identifying the architectural landscape for your system as they enable you to model the high-level software components, and more importantly the interfaces to those components. [Agile Modeling]

4. Component Diagram Example
A component diagram provides a physical view of the system. Its purpose is to show the dependencies that the software has on the other software components (e.g., software libraries) in the system. The diagram can be shown at a very high level, with just the large-grain components, or it can be shown at the component package level.
Modeling a component diagram is best described through an example. Figure below shows four components: Reporting Tool, Billboard Service, Servlet 2.2 API, and JDBC API. The arrowed lines from the Reporting Tool component to the Billboard Service, Servlet 2.2 API, and JDBC API components mean that the Reporting Tool is dependent on those three components.

5. Component Diagram Example in UML 1.4

6. Component Diagram Example in UML 2

7. Basic Notation Used in Component Diagrams
Drawing a component in UML 2 is now very similar to drawing a class on a class diagram. In fact, in UML 2 a component is merely a specialized version of the class concept. Which means that the notation rules that apply to the class classifier also apply to the component classifier.
In UML 2, a component is drawn as a rectangle with optional compartments stacked vertically. A high-level, abstracted view of a component in UML 2 can be modeled as just a rectangle with the component's name and the component stereotype text and/or icon. The component stereotype's text is «component»" and the component stereotype icon is a rectangle with two smaller rectangles protruding on its left side (the UML 1.4 notation element for a component).
When drawing a component on a diagram, it is important that you always include the component stereotype text (the word "component" inside double angle brackets, as shown in Figure below) and/or icon. The reason? In UML, a rectangle without any stereotype classifier is interpreted as a class element. The component stereotype and/or icon distinguishes this rectangle as a component element.
Creating Component Diagrams
There are two fundamental strategies for developing a component model, either top down or bottom up.  Given the choice I prefer the top-down approach because it provides a good mechanism for identifying the “software landscape” early in the project, something that is particularly important for teams comprised of several subteams because you want to work towards the same vision.  Unfortunately a top-down approach suffers from the tendency to promote over-architecting, and hence over-building, of your system.  For example Figure 1 calls out Security and Persistence components but you might not yet need anything even remotely that complicated.  It would be a serious mistake to focus on building these two components instead of implementing actual business functionality that your stakeholders actually need. 
A second way to develop component models is from the bottom up.  I’ll do this when we have an existing collection of classes that have been developed and we decide to componentize our design.  Componentizing is often done to rescue reusable functionality out of an existing application or to split an application up so it can be easily dispersed between subteams.   When I’m componentizing an existing object design I’ll often iterate through the following steps:
Keep components cohesive.  A component should implement a single, related set of functionality.  This may be the user interface logic for a single user application, business classes comprising a large-scale domain concept, or technical classes representing a common infrastructure concept.
Assign user interface classes to application components.  User interface classes, those that implement screens, pages, or reports, as well as those that implement “glue logic” such as identifying which screen/page/… to display should be placed in components with the application stereotype.  In Java these types of classes would include Java Server Pages (JSPs), servlets, and screen classes implemented via user interface class libraries such as Swing.
Assign technical classes to infrastructure components.  Technical classes, such as those that implement system-level services such as security, persistence, or middleware should be assigned to components which have the infrastructure stereotype.
Define class contracts.  A class contract is any method that directly responds to a message sent from other objects.  For example, the contracts of the Seminar class likely include operations such as enrollStudent() and dropStudent(). For the purpose of identifying components, you can ignore all the operations that aren’t class contracts because they don’t contribute to communication between objects distributed in different components.
Assign hierarchies to the same component.  99.9% of the time I find that it makes sense to assign all of the classes of a hierarchy, either an inheritance hierarchy or a composition hierarchy, to the same component. 
Identify domain components. A domain component is a set of classes that collaborate among themselves to support a cohesive set of contracts. The basic idea is that classes, and even other domain components, are able to send messages to domain components either to request information or to request an action be performed. On the outside, domain components appear simple, actually they appear like any other type of object but, on the inside, they are often quite complex because they encapsulate the behavior of several classes.  A key goal is you want to organize your design into several components in such a way as to reduce the amount of information flowing between them. Any information passed between components, either in the form of messages or the objects that are returned as the result of a message send, represents potential traffic on your network (if the components are deployed to different nodes). Because you want to minimize network traffic to reduce the response time of your application, you want to design your domain components in such a way that most of the information flow occurs within the components and not between them.
Identify the “collaboration type” of business classes.  To determine which domain component a business class belongs to you need to analyze the collaborations it is involved with to determine its distribution type. A server class is one that receives messages, but doesn’t send them. A client class is one that sends messages, but doesn’t receive them. A client/server class is one that both sends and receives messages.  Once you have identified the distribution type of each class, you are in a position to start identifying potential domain components.
Server classes belong in their own component. Pure server classes belong in a domain component and often form their own domain components because they are the “last stop” for message flow within an application.
Merge a component into its only client. If you have a domain component that is a server to only one other domain component, you may decide to combine the two components.   
Pure client classes don’t belong in domain components. Client classes don’t belong in a domain component because they only generate messages, they don’t receive them, whereas the purpose of a domain component is to respond to messages. Therefore, client classes have nothing to add to the functionality offered by a domain component and very likely belong in an application component instead.
Highly coupled classes belong in the same component. When two classes collaborate frequently, this is an indication they should be in the same domain component to reduce the network traffic between the two classes. This is especially true when that interaction involves large objects, either passed as parameters or received as return values. By including them in the same domain component you reduce the potential network traffic between them. The basic idea is that highly coupled classes belong together.
Minimize the size of the message flow between components. Client/server classes belong in a domain component, but there may be a choice as to which domain component they belong to. This is where you need to consider issues such as the information flow going into and out of the class.  Communication within a component will often be simple message sends between objects in memory, communication between components may require an expensive marshalling effort in which a message and its parameters are converted to data, transmitted, and then converted back into a message again.
Define component contracts.  Each component will offer services to its clients, each such service is a component contract.

8. Modeling a Component's Interfaces
UML 2 has also introduced another way to show a component's provided and required interfaces. This second way builds off the single rectangle, with the component's name in it, and places what the UML 2 specification calls interface symbols" connected to the outside of the rectangle.
In this second approach the interface symbols with a complete circle at their end represent an interface that the component provides -- this lollipop" symbol is shorthand for a realization relationship of an interface classifier. Interface symbols with only a half circle at their end (a.k.a. sockets) represent an interface that the component requires (in both cases, the interface's name is placed near the interface symbol itself). For example, the Order component provides two interfaces: OrderEntry and AccountPayable, and the Order component requires the Person interface.

9. Interfaces and Ports
Components may both provide and require interfaces.  An interface is the definition of a collection of one or more methods, and zero or more attributes, ideally one that defines a cohesive set of behaviors.  A provided interface is modeled using the lollipop notation and a required interface is modeled using the socket notation.  A port is a feature of a classifier that specifies a distinct interaction point between the classifier and its environment.  Ports are depicted as small squares on the sides of classifiers.
Ports can be named, such as the Security and Data ports on the Student component.
Ports can support unidirectional communication or bi-directional communication.  The Student component implements three ports, two unidirectional ports and one bi-directional ports.  The left-most port is an input port, the Security port is an output port, and the Data port is a bi-directional port.

10. Beyond the Basics
The component diagram is one of the easier-to-understand diagrams, so there is not much to cover beyond the basics.
There will be times when it makes sense to display a component's internal structure. To show a component's inner structure, you merely draw the component larger than normal and place the inner parts inside the name compartment of the encompassing component. Figure below, show's the Store's component inner structure.

11. What is a Deployment Diagram
The deployment diagram shows how a system will be physically deployed in the hardware environment. Its purpose is to show where the different components of the system will physically run and how they will communicate with each other. Since the diagram models the physical runtime, a system's production staff will make considerable use of this diagram.
The notation in a deployment diagram includes the notation elements used in a component diagram, with a couple of additions, including the concept of a node. A node represents either a physical machine or a virtual machine node (e.g., a mainframe node). To model a node, simply draw a three-dimensional cube with the name of the node at the top of the cube. Use the naming convention used in sequence diagrams.

12. Deployment Diagram Example
The deployment diagram below shows that the users access the Reporting Tool by using a browser running on their local machine and connecting via HTTP over their company's intranet to the Reporting Tool. This tool physically runs on the Application Server named w3reporting.myco.com. The diagram shows the Reporting Tool component drawn inside of IBM WebSphere, which in turn is drawn inside of the node w3.reporting.myco.com. The Reporting Tool connects to its reporting database using the Java language to IBM DB2's JDBC interface, which then communicates to the actual DB2 database running on the server named db1.myco.com using native DB2 communication. In addition to talking to the reporting database, the Report Tool component communicates via SOAP over HTTPS to the Billboard Service.

13. UML Deployment Diagram Example
The three-dimensional boxes represent nodes, either software or hardware.  Physical nodes should be labeled with the stereotype device, to indicate that it is a physical device such as a computer or switch. 
Connections between nodes are represented with simple lines, and are assigned stereotypes such as RMI and message bus to indicate the type of connection.  

14. Concise UML 2 Deployment Diagram
A better example is shown in the figure below. Software elements are now simply listed by their physical filenames, information that developers are very likely to be interested in, and thus a more compact diagram is possible.  A drum is used as a visual stereotype for the University DB database, making it easier to distinguish on the diagram. Another difference is that the concise version shows less details, not as many tagged values are shown as this information can be captured in either supporting documentation, configuration files, or source code. 

15. Network Diagrams
Network diagrams are often drawn using software-based drawing tools (figure below was drawn using Microsoft Visio)

16. Summary Slide What is a Component Diagram
Component Diagram Example in UML 1.4
Component Diagram Example in UML 2
Basic Notation Used in Component Diagrams
Modeling a Component's Interfaces
Interfaces and Ports
Beyond the Basics
What is a Deployment Diagram
Deployment Diagram Example
UML Deployment Diagram Example
Concise UML 2 Deployment Diagram
Network Diagrams