Zelf een deployment diagram maken: handleiding

De Unified Modeling Language (UML) is de standaardtaal die veel software engineers en zakelijke professionals gebruiken om een breed overzicht te creëren van complexe systemen. Een deployment diagram (implementatiediagram) is een van de typen diagrammen die met deze taal worden gemaakt. Gebruik deze handleiding samen met onze tool voor UML-diagrammen om meer te weten te komen over deployment diagrammen. Ben je klaar om er zelf een te bouwen? Dan bevat deze tutorial ook praktische stappen voor het tekenen, opmaken en delen van een voltooid deployment diagram in Lucidchart.

Wat is een deployment diagram?

Binnen de Unified Modeling Language (UML) valt een deployment diagram onder de familie van structuurdiagrammen, omdat het een specifiek aspect van het systeem zelf beschrijft. In dit geval beschrijft het deployment diagram de fysieke implementatie van informatie die door het softwareprogramma wordt gegenereerd op hardwarecomponenten. De informatie die de software genereert, noemen we een artefact (artifact). Dit moet niet worden verward met het gebruik van deze term binnen andere modelleerbenaderingen, zoals BPMN.

Deployment diagrammen zijn opgebouwd uit verschillende UML-vormen. De driedimensionale kaders, nodes of knooppunten genoemd, vertegenwoordigen de elementaire software- of hardware-elementen in het systeem. Lijnen van node naar node geven relaties aan, en de kleinere vormen binnen de kaders stellen de geïmplementeerde software-artefacten voor. Omdat ze hardware kunnen beschrijven, zijn deployment diagrammen uniek binnen de UML-wereld.

Toepassingen van een deployment diagram

Deployment diagrammen kennen verschillende waardevolle toepassingen. Je kunt ze gebruiken om:

• Te laten zien welke software-elementen door welke hardware-elementen worden geïmplementeerd.
• De runtime processing voor hardware inzichtelijk te maken.
• Een overzicht te geven van de topologie van het hardwaresysteem.

Richtlijnen voor een deployment diagram

Gebruik de tool voor UML-diagrammen van Lucidchart om deployment diagrammen te maken. Stel jezelf de volgende vragen voordat je begint met het maken van je diagram:

1. Heb je de scope van je systeem bepaald? Zo moet je weten of je een diagram maakt van een enkele applicatie of van de implementatie op een heel netwerk van computers.
2. Wat zijn de beperkingen van je fysieke hardware? Met welke legacy-systemen moet je communiceren? Zorg ervoor dat je weet met welke besturingssoftware en protocollen je gaat werken en welke monitoring je gaat inrichten.
3. Welke distributiearchitectuur gebruik je? Je moet weten uit hoeveel lagen (tiers) je applicatie zal bestaan en naar welke applicatie je implementeert.
4. Heb je alle benodigde nodes in kaart gebracht? Weet je hoe ze allemaal met elkaar verbonden zijn?
5. Weet je welke componenten op welke nodes komen te staan?

Zodra je deze vragen hebt beantwoord, kan het helpen om een eenvoudige inventarisatie te maken van de nodes die je wilt weergeven en hoe ze met elkaar samenhangen, om die lijst vervolgens om te zetten in UML-notatie.

Elementen van een deployment diagram

Deployment diagrammen bestaan uit verschillende vormen. Deze lijst biedt een overzicht van de basiselementen die je tegenkomt. De meeste hiervan zijn te zien in de onderstaande afbeelding.

• Artefact (artifact): Een product dat door de software is ontwikkeld, weergegeven door een rechthoek met de naam en het woord "artifact" tussen dubbele pijlen.
• Associatie (association): Een lijn die een bericht of ander type communicatie tussen nodes aangeeft.
• Component: Een rechthoek met twee uitsteeksels die een software-element aangeeft.
• Afhankelijkheid (dependency): Een stippellijn die eindigt in een pijl, wat aangeeft dat een node of component afhankelijk is van een andere.
• Interface: Een cirkel die een contractuele relatie aangeeft. Objecten die de interface implementeren, moeten aan een bepaalde verplichting voldoen.
• Node (knooppunt): Een hardware- of softwareobject, weergegeven door een driedimensionaal kader.
• Node als container: Een node die een andere node bevat—zoals in het onderstaande voorbeeld, waarin de nodes componenten bevatten.
• Stereotype: Een apparaat binnen de node, bovenaan weergegeven met de naam tussen dubbele pijlen.

In de praktijk bepaal je vaak eerst het doel van het diagram (bijvoorbeeld topologie versus runtime processing), om vervolgens te kiezen welke elementen je nodig hebt om dat doel helder over te brengen.

Symbolen en notatie voor deployment diagrammen

Gebruik deze vormen bij het bouwen van je UML-implementatiediagrammen.

Nodes (knooppunten)

Er zijn twee soorten nodes in een deployment diagram: device nodes en execution environment nodes. Device nodes zijn computermiddelen met verwerkingskracht en de mogelijkheid om programma's uit te voeren. Voorbeelden van device nodes zijn pc's, laptops en smartphones.

Execution environment nodes zijn computersystemen die zich binnen device nodes bevinden, zoals besturingssystemen, JVM's of servlet containers.

Database

Databases vertegenwoordigen alle gegevens die door het geïmplementeerde systeem worden opgeslagen. In sommige gevallen zie je een database weergegeven als gewoon een node, maar soms wordt hiervoor een specifieke databasevorm gebruikt.

Overige vormen

• Communicatiepad: Een rechte lijn die communicatie tussen twee device nodes voorstelt.
• Artefacten: Een kader met de header "<>" gevolgd door de naam van het bestand.
• Pakket (package): Een tabblad- of mapvormig kader dat alle device nodes groepeert om de gehele implementatie in te kapselen.
• Component: Een entiteit die vereist is om een stereotype-functie uit te voeren.

Houd er bij het plaatsen van deze symbolen rekening mee dat deployment diagrammen kunnen variëren van heel eenvoudig tot zeer gedetailleerd. Zo kun je bijvoorbeeld de ene node binnen een andere nesten om een specifiek implementatiepatroon weer te geven.

Voorbeeld van een deployment diagram

Dit voorbeeld toont een basisimplementatiediagram voor Lucidchart. Er is een webserver, een databaseserver en het apparaat waarop de gebruiker de website bekijkt. Je kunt meer complexiteit toevoegen door de verschillende onderdelen van de webserver en de werking van JavaScript op de UserClient te tonen, maar dit voorbeeld geeft je al een goed beeld van hoe een implementatie eruitziet in UML-notatie.

Zo teken je een deployment diagram in Lucidchart

Zodra je de basisnotatie begrijpt, is de volgende stap het omzetten van je model in een overzichtelijk, deelbaar diagram. De onderstaande workflow volgt een praktische volgorde: richt je canvas in, bepaal wat je wilt laten zien, voeg vormen toe en verbind ze, en publiceer of download vervolgens het resultaat.

1. Aan de slag met Lucidchart

De eerste stap bij het maken van een sterk UML-diagram is je aanmelden bij Lucidchart. Lucidchart biedt een intuïtieve interface, kant-en-klare sjablonen en uitgebreide vormbibliotheken, waardoor het ontwerpen van complexe deployment diagrammen een koud kunstje is.

Zodra je bent ingelogd bij Lucidchart, maak je een nieuw leeg document aan en schakel je de UML-vormbibliotheken in. Klik op Vormen in de linkerbovenhoek van je scherm en vink "UML" aan in het menu dat verschijnt. Nu zijn alle UML-vormen van Lucidchart beschikbaar aan de linkerkant van het canvas.

2. Componenten in kaart brengen

Begin met helder voor ogen te krijgen wat je met het diagram wilt overbrengen en maak een lijst van de nodes en de software-elementen die daarop worden geïmplementeerd. Deployment diagrammen kunnen verschillende doeleinden dienen, die allemaal verband houden met hardware. Enkele van deze functies zijn:

• Het vastleggen van runtime processing voor hardware-elementen

• Het visualiseren van de algemene topologie voor een specifiek hardwaresysteem

• Het aantonen van de manier waarop bepaalde softwarecomponenten worden geïmplementeerd door specifieke hardwarecomponenten

Zodra je het doel van je implementatiediagram hebt vastgesteld, bepaal je welke elementen erin moeten worden opgenomen. De belangrijkste elementen van elk deployment diagram zijn de nodes (knooppunten). Deze grote 3D-kaders symboliseren de elementen die objecten implementeren. De objecten binnen de kaders—zoals stereotypes, artefacten en componenten (een component is te zien in het onderstaande voorbeeld)—zijn de objecten die worden geïmplementeerd.

Lijnen van node naar node geven relaties aan tussen nodes of relaties tussen de berichten die ze verzenden. Houd er rekening mee dat deployment diagrammen een hoge mate van complexiteit kunnen bereiken. Afhankelijk van het implementatiepatroon dat je wilt uitdrukken, kan de ene node zich bijvoorbeeld binnen een andere node bevinden. Het kan handig zijn om te beginnen met een lijst die duidelijk aangeeft welke nodes je wilt weergeven en hoe ze met elkaar samenhangen.

3. Vormen toevoegen

Schakel de UML-vormbibliotheken in om te beginnen met het tekenen van je diagram in Lucidchart. Sleep vanuit de UML-vormbibliotheek voor implementatiediagrammen je eerste symbool naar het canvas: een node. Geef deze een label en kies welke vormen binnen de node moeten worden geplaatst. Je kunt een artefact, een component, een instantie of een basisobject toevoegen. Je kunt heel eenvoudig elementen in de node toevoegen, verwijderen of vervangen. Om een element een andere naam te geven, klik je erop en begin je direct te typen.

Voeg na je eerste node meer nodes toe en voorzie ze van labels totdat de structuur van je diagram compleet is. Voeg vervolgens de componentvormen toe die in de nodekaders worden geïmplementeerd.

4. Nodes met elkaar verbinden

Vervolgens ben je klaar om de nodes met elkaar te verbinden. Om een lijn toe te voegen, sleep je met je muis vanuit de rode cirkel die verschijnt wanneer je over de vorm beweegt en verbind je deze met de juiste vorm.

5. Pijlen opmaken

Wanneer je relaties tekent tussen elementen binnen de nodes, zul je waarschijnlijk complexere verbindingen moeten weergeven. In de editor van Lucidchart kun je de stijl en de pijlen van elke lijn aanpassen om een uniek type relatie aan te duiden. Gebruik hiervoor simpelweg de eigenschappenbalk boven het canvas.

6. Je diagram voltooien

Blijf lijnen en nodes toevoegen totdat je het hele systeem hebt beschreven. Voel je vrij om verschillende kleuren aan je diagram toe te voegen om de inhoud nog overzichtelijker en toegankelijker te maken.

7. Publiceren, implementeren en delen

Gefeliciteerd! Je hebt je deployment diagram nu voltooid. Zodra je klaar bent, kun je je deployment diagram publiceren en delen met je team als snel naslagwerk of om het onboardingproces te versnellen.

Om je document te delen met medewerkers (zowel Lucidchart-gebruikers als niet-gebruikers), klik je op de oranje knop Delen in de rechterbovenhoek van je scherm. Vanuit ditzelfde menu kun je je diagram ook eenvoudig op sociale media plaatsen.

Om je diagram te downloaden, klik je op Bestand > Downloaden als en kies je het gewenste bestandstype. Door je document te downloaden, kun je het diagram verspreiden zonder dat je bang hoeft te zijn dat anderen onbedoelde wijzigingen aanbrengen. Het publiceren en delen van je diagrammen is bijzonder eenvoudig met Lucidchart.

Na het doornemen van deze handleiding kun je direct je eigen deployment diagram tekenen met Lucidchart: een gratis platform voor visuele communicatie waarmee je strakke, professionele diagrammen maakt.

Klaar om je eigen UML-diagram te maken? Probeer Lucidchart. Het is snel, eenvoudig en gratis om te beginnen.