def generate(name, num_of_instances):
with Diagram(name, direction='TB', show=True):
with Cluster('Auto Scaling Group'):
app_group = [EC2Instance('App') for _ in range(num_of_instances)]
rds_master = RDS('DB (Master)')
rds_standby = RDS('DB (Standby)')
Users('Users') >> Route53('Route 53') >> ALB('ALB') >> app_group >> rds_master
rds_master - rds_standby
def test3():
filename = os.path.join(img_dir, sys._getframe().f_code.co_name)
with Diagram("Simple Web Service with DB Cluster", show=False, filename=filename):
dns = Route53("dns")
web = ECS("service")
with Cluster("DB Cluster"):
db_master = RDS("master")
db_master - [RDS("slave1"), RDS("slave2")]
dns >> web >> db_master
def test2():
filename = os.path.join(img_dir, sys._getframe().f_code.co_name)
with Diagram("Grouped Workers", show=False, direction="TB", filename=filename):
ELB("lb") >> [EC2("worker1"),
EC2("worker2"),
EC2("worker3"),
EC2("worker4"),
EC2("worker5")] >> RDS("events")
def test1():
filename = os.path.join(img_dir, sys._getframe().f_code.co_name)
with Diagram("Workers", show=False, direction="TB", filename=filename):
lb = ELB("lb")
db = RDS("events")
lb >> EC2("worker1") >> db
lb >> EC2("worker2") >> db
lb >> EC2("worker3") >> db
lb >> EC2("worker4") >> db
lb >> EC2("worker5") >> db
def draw(name: str, *, show: bool = False) -> None:
with Diagram(name):
dns = Route53()
lb = ELB()
with Cluster() as Services:
web1 = ECS()
web2 = ECS()
web3 = ECS()
with Cluster() as DBCluster:
userdb = RDS()
userdb_ro = RDS()
userdb - [userdb_ro]
memcached = ElastiCache()
dns >> lb >> Services
Services >> DBCluster
Services >> memcached
cf = CF('Cloudfront CDN')
with Cluster('VPC'):
with Cluster("WebProxy AutoScalingGroup (ASG)"):
web_asg = AutoScaling('ASG')
web_lb = ELB("NLB")
with Cluster("Application servers AutoScalingGroup (ASG)"):
app_asg = AutoScaling('ASG')
app_lb = ELB("NLB")
with Cluster("AWS Batch"):
cwa = cw('CW Event')
batch_s3 = S3('Batch data')
batch = Batch('AWS Batch')
with Cluster("DB Cluster"):
db_master = RDS("master")
db_master - [RDS("slave")]
users >> dns
users >> cf
cf >> s3_content
dns >> web_lb >> web_asg
web_asg >> app_lb >> app_asg
app_asg >> db_master
app_asg >> batch_s3
app_asg >> s3_content
cwa >> batch << batch_s3
batch_s3 >> db_master
from diagrams.onprem.container import Docker
from diagrams.onprem.database import PostgreSQL
from diagrams.onprem.monitoring import Grafana, Prometheus
from diagrams.onprem.network import Internet
from diagrams.programming.framework import Spring, React
graph_attr = {
"fontsize": "20",
"bgcolor": "white" #transparent
}
with Diagram("Application Architecture",
graph_attr=graph_attr,
outformat="png",
filename="application_architecture"):
ELB("lb") >> EC2("web") >> RDS("userdb") >> S3("store")
ELB("lb") >> EC2("web") >> RDS("userdb") << EC2("stat")
(ELB("lb") >> EC2("web")) - EC2("web") >> RDS("userdb")
with Cluster("Application Context"):
app = EC2("Spring Boot")
ELB("lb") >> app
metrics = Prometheus("metric")
metrics << Edge(color="firebrick", style="dashed") << Grafana("monitoring")
Jenkins("CI")
client = Client("A")
client >> User("B") >> Users("S")
client >> PostgreSQL("Database")
from diagrams import Cluster, Diagram
from diagrams.aws.compute import ECS
from diagrams.aws.database import ElastiCache, RDS
from diagrams.aws.network import ELB
from diagrams.aws.network import Route53
with Diagram("Clustered Web Services",
filename="out/aws-001",
outformat="svg",
show=False):
dns = Route53("dns")
lb = ELB("lb")
with Cluster("Services"):
svc_group = [ECS("web1"), ECS("web2"), ECS("web3")]
with Cluster("DB Cluster"):
db_master = RDS("userdb")
db_master - [RDS("userdb ro")]
memcached = ElastiCache("memcached")
dns >> lb >> svc_group
svc_group >> db_master
svc_group >> memcached
from diagrams.firebase.base import Firebase
from diagrams.azure.database import CosmosDb, SQLDatabases, CacheForRedis
from diagrams.azure.storage import BlobStorage
from diagrams.aws.database import Dynamodb, RDS, Elasticache
from diagrams.aws.storage import S3
node_attr = {"fontsize": "20"}
graph_attr = {"fontsize": "28"}
with Diagram("", show=False, direction="TB", node_attr=node_attr):
with Cluster("On-Premises", graph_attr=graph_attr):
with Cluster("Relational Database", graph_attr=graph_attr):
relational = Mssql("")
relational - [Oracle("")]
with Cluster("Document Database", graph_attr=graph_attr):
documentdb = Mongodb("\nMongoDB")
documentdb - [Couchdb("\nCouchDB")] - Firebase("\nFirebase")
with Cluster("Cache", graph_attr=graph_attr):
cache = Redis("\nRedis")
cache - [Memcached("\nMemcached")] - Hazelcast("\nHazelcast")
with Cluster("Cloud", graph_attr=graph_attr):
with Cluster("Azure", graph_attr=graph_attr):
azure = CosmosDb("\nCosmos DB")
azure - [
SQLDatabases("\nSQL DB")
] - CacheForRedis("\nRedis") - BlobStorage("\nBlob Storage")
with Cluster("AWS", graph_attr=graph_attr):
aws = Dynamodb("\nDynamoDB")
aws - [RDS("\nRDS")] - Elasticache("\nElasticache") - S3("\nS3")
# Contributors:
# Pavel Tisnovsky
#
from diagrams import Diagram
from diagrams.onprem.queue import Kafka, ActiveMQ
from diagrams.programming.language import Go, Rust
from diagrams.aws.database import RDS
# definice diagramu se specifikaci jeho zakladnich vlastnosti
with Diagram("OnPrem #6", show=True, direction="TB"):
# definice uzlu - konzument
consumer = Kafka("input stream")
# definice uzlu - databaze
db = RDS("storage")
# rozvetveni - vetsi mnozstvi workeru
workersA = [Go("worker #1"), Go("worker #2"), Go("worker #3")]
# buffer vlozeny mezi skupiny workeru
buffer = ActiveMQ("buffer")
# rozvetveni - vetsi mnozstvi workeru
workersB = [Rust("worker #1"), Rust("worker #2"), Rust("worker #3")]
# definice uzlu - producent
producer = Kafka("output stream")
# propojeni uzlu grafu orientovanymi hranami
consumer >> workersA >> buffer >> workersB >> producer
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from diagrams import Cluster, Diagram
from diagrams.aws.compute import ECS
from diagrams.aws.database import Elasticache, RDS
from diagrams.aws.network import ELB, Route53
# In[2]:
with Diagram('Clustered Web Services', show=False):
dns = Route53('dns')
lb = ELB('lb')
with Cluster('Services'):
svc_group = [ECS('web1'), ECS('web2'), ECS('web3')]
with Cluster('DB Cluster'):
db_master = RDS('userdb')
db_master = [RDS('userdb ro')]
memcached = Elasticache('memcached')
dns >> lb >> svc_group
svc_group >> db_master
svc_group >> memchaced
# In[ ]:
route53ApiNingenmeNet = Route53("api.ningenme.net")
route53StaticNingenmeNet = Route53("static.ningenme.net")
with Cluster("cloud front"):
cloudFrontNingenmeNet = CloudFront("ningenme.net")
cloudFrontApiNingenmeNet = CloudFront("api.ningenme.net")
cloudFrontStaticNingenmeNet = CloudFront("static.ningenme.net")
with Cluster("s3"):
s3StaticNingenmeNet = S3("static.ningenme.net")
with Cluster("alb"):
albNetFront = ALB("net-front")
albNetApi = ALB("net-api")
with Cluster("ecs-cluster"):
ecsNetFront = ECS("net-front")
ecsNetApi = ECS("net-api")
with Cluster("db"):
mysql = RDS("ningenme-mysql")
with Cluster("code deploy"):
codeDeployNetFront = Codedeploy("net-front")
codeDeployNetApi = Codedeploy("net-api")
with Cluster("GitHub"):
with Cluster("github actions"):
actionsNetFront = GithubActions("net-front")
actionsNetApi = GithubActions("net-api")
with Cluster("github"):
githubNetFront = Github("net-front")
githubNetApi = Github("net-api")
githubAwsTerraform = Github("aws-terraform")
user >> route53ApiNingenmeNet >> cloudFrontApiNingenmeNet >> albNetApi >> ecsNetApi << codeDeployNetApi << actionsNetApi << githubNetApi
user >> route53NingenmeNet >> cloudFrontNingenmeNet >> albNetFront >> ecsNetFront << codeDeployNetFront << actionsNetFront << githubNetFront
user >> route53StaticNingenmeNet >> cloudFrontStaticNingenmeNet >> s3StaticNingenmeNet << actionsNetApi
aaDpA = ConsoleMobileApplication("Deployed Application")
with Cluster("Sentry Exception Monitoring"):
semELB = ElasticLoadBalancing("Load Balancer")
with Cluster("Sentry Application Services"):
sasECS1 = ECS("ECS Container")
sasECS2 = ECS("ECS Container")
sasECS3 = ECS("ECS Container")
ses = SimpleEmailServiceSes("SES Email")
with Cluster("Redis Cache"):
rcECS1 = ECS("ECS Container")
rcCloudmap = CloudMap("AWS CloudMap")
with Cluster("Sentry Artifact Store"):
s3 = S3("S3 Bucket")
with Cluster("Sentry Database"):
sdRDS = RDS("Relational Database Service for Postgres")
#STEP2:set up relationships
#format entities within one group
gsIamUser - Edge(color="transparent") - gsServer
genericSamlToken - Edge(color="transparent") - codeRepo
aaCloud - Edge(color="transparent") - aaCli
ses - Edge(color="transparent") - sasECS1
sasECS2 - Edge(color="transparent") - sasECS3
sasECS1 - Edge(color="transparent") - rcECS1 - Edge(color="transparent") - s3 - Edge(color="transparent") - sdRDS
#connect between entities
#orange: Jenkins CI/CD
gsServer >> Edge(color = "#C55A11", label= "If the code is for a mobile app \n the build is performed on \n Apple MacOS build service") << jsECS
from diagrams import Cluster, Diagram, Edge
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB, VPC, NATGateway, InternetGateway
from diagrams.aws.management import SystemsManager as SSM
from diagrams.onprem.client import Users
from diagrams.onprem.network import Internet
with Diagram("3 Tier Web Module", show=False):
users = Users("Users")
internet = Internet("Internet")
with Cluster("Region Sa-East-1"):
ssm = SSM("SSM Management")
with Cluster("VPC"):
with Cluster("subnet/public"):
igw = InternetGateway("InternetGateway")
lb = ELB("lb")
with Cluster("subnet/private"):
with Cluster("App"):
auto_scaling_group = [EC2("app1"), EC2("app2")]
with Cluster("Database"):
database = RDS("app_db")
natgw = NATGateway("NATGW")
users >> internet >> lb >> auto_scaling_group
natgw - auto_scaling_group
auto_scaling_group - Edge(style="dotted") - database
ssm >> Cluster("subnet/private")
from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
with Diagram('Grouped Workers', show=False,
direction='TB',
filename='img/example'):
ELB('lb') >> [EC2('worker1'),
EC2('worker2'),
EC2('worker3'),
EC2('worker4'),
EC2('worker5')] >> RDS('events')
from diagrams.gcp.database import BigTable
from diagrams.gcp.iot import IotCore
from diagrams.gcp.storage import GCS
diagram_name = "Grouped Workers"
with Diagram(diagram_name,
show=False,
direction="TB",
filename="diagrams/" + diagram_name):
ELB("lb") >> [
EC2("worker1"),
EC2("worker2"),
EC2("worker3"),
EC2("worker4"),
EC2("worker5")
] >> RDS("events")
diagram_name = "Clustered Web Services"
with Diagram(diagram_name, show=False, filename="diagrams/" + diagram_name):
dns = Route53("dns")
lb = ELB("lb")
with Cluster("Services"):
svc_group = [ECS("web1"), ECS("web2"), ECS("web3")]
with Cluster("DB Cluster"):
db_master = RDS("userdb")
db_master - [RDS("userdb ro")]
memcached = ElastiCache("memcached")
from diagrams import Diagram
from diagrams.aws.network import APIGateway
from diagrams.aws.compute import Lambda
from diagrams.aws.database import RDS
with Diagram("fiber-aws-serverless", filename="./docs/aws_diagram",
show=False):
APIGateway("http-gateway") >> Lambda("fiber-app") >> RDS("aws RDS")
from diagrams.aws.compute import EC2
from diagrams.aws.compute import AutoScaling
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
from diagrams.aws.management import Cloudwatch
from diagrams.aws.storage import S3
with Diagram("AIK Archicteture Diagram Solution", show=False):
bucket = S3("Bucket x3")
vpc = Cluster("VPC")
with vpc:
loadBal = ELB("ELB")
jenkins = EC2("Jenkins CI/CD Server")
with Cluster("EC2 Instances - AutoScaling Group"):
ec2_1 = EC2("AIK App")
ec2_2 = EC2("AIK App")
with Cluster("DB RDS MySQL"):
rds = RDS("")
rds << Edge(label="") >> ec2_1
rds << Edge(label="") >> ec2_2
loadBal >> ec2_1
loadBal >> ec2_2
ec2_1 >> bucket
ec2_2 >> bucket
ec2_1 << Cloudwatch("CloudWatch")
ECS("master3")]
with Cluster("Infra nodes"):
infra_group = [ECS("infranode1"),
ECS("infranode2")]
with Cluster("Worker nodes"):
worker_group = [ECS("workernode1"),
ECS("workernode2")]
with Cluster("CA bundle, http://bit.ly/marcredhatcerts"):
ca_bundle = ECS("CA bundle")
with Cluster("Storage, http://bit.ly/marcredhatstorage"):
storage = RDS("Container registry")
storage - [RDS("Apps")]
with Cluster("Developers and Admins"):
devs_and_admins = User("Developers")
devs_and_admins - [User("Admins")]
with Cluster("Users"):
users = [User("Users")]
with Cluster("Operations VLAN"):
operations_VLAN = [Server("GitlabCI"),
Server("Jenkins"),
Server("Bamboo"),
Server("LDAP"),
from diagrams import Cluster, Diagram
from diagrams.aws.compute import ECS
from diagrams.aws.database import ElastiCache, RDS
from diagrams.aws.network import ELB
from diagrams.aws.network import Route53
# https://diagrams.mingrammer.com/docs/getting-started/examples
with Diagram("Clustered Web Services", show=False):
dns = Route53("dns")
lb = ELB("lb")
with Cluster("Services"):
svc_group = [ECS("web1"), ECS("web2"), ECS("web3")]
with Cluster("DB Cluster"):
db_main = RDS("userdb")
db_main - [RDS("userdb ro")]
memcached = ElastiCache("memcached")
dns >> lb >> svc_group
svc_group >> db_main
svc_group >> memcached
# diagram.py
# Needs diagrams from pip and graphwiz installed
from diagrams import Cluster, Diagram
#from diagrams.aws.network.ElasticLoadBalancing import ELB
from diagrams.aws.compute import AutoScaling
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import Route53
from diagrams.aws.network import ELB
from diagrams.aws.storage import S3
with Diagram("Artifactory", show=False):
dns = Route53("dns")
lb = ELB("lb")
with Cluster("DB Security Group"):
RDS("MySql")
S3("Artifact Store")
from diagrams import Diagram, Cluster
from diagrams.aws.compute import EC2
from diagrams.aws.database import DB, RDS
from diagrams.aws.network import ELB
with Diagram("Workers", show=False, direction="TB"):
with Cluster("Python"):
votingApp = EC2("voting-app")
with Cluster("Redis"):
redis = RDS("redis")
with Cluster(".NET"):
svc_group = [
EC2("worker 1"),
EC2("worker 2"),
EC2("worker 3"),
EC2("worker 4"),
EC2("worker 5")
]
with Cluster("DB PostgreSql"):
postgreSql = DB("db")
with Cluster("Node.js"):
resultApp = EC2("result-app")
votingApp >> redis
redis >> svc_group
from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
with Diagram("Grouped Workers", show=False, direction="TB"):
ELB("lb") >> [
EC2("worker1"),
EC2("worker2"),
EC2("worker3"),
EC2("worker4"),
EC2("worker5")
] >> RDS("events")
"""
quick start from diagrams
"""
from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB, CF
from diagrams.aws.storage import S3, EFS
with Diagram("Web Service", show=True):
workers = [
EC2("1-web"),
]
shared = EFS('wp-content')
balancer = ELB('lb')
cdn = CF('cdn')
static = S3('wp-static')
db = RDS('wp-tables')
balancer >> workers >> db
workers >> static
workers >> shared
cdn >> static
cm = CertificateManager("CertificateManager")
listener = InternetGateway(":443")
with Cluster("VPC: 172.16.x.x"):
lb = ELB("ALB")
with Cluster("ECS"):
with Cluster("Public Subnet #1"):
ecs_stack_1 = ECS("rshiny-app-1")
with Cluster("Public Subnet #2"):
ecs_stack_2 = ECS("rshiny-app-2")
with Cluster("Private Subnet #1"):
with Cluster("RDS Cluster"):
db_1 = RDS("postgresql db")
users << dns >> lb
users >> listener >> lb
lb >> Edge(label=":8080") >> ecs_stack_1
lb >> Edge(label=":8080") >> ecs_stack_2
ecs_stack_1 >> Edge(label=":5432") >> db_1
ecs_stack_2 >> Edge(label=":5432") >> db_1
db_1 << cw
ecs_stack_1 << cw
ecs_stack_2 << cw
cm << Edge(label="Use certificate") << lb
lb >> s3
iam - Edge(style="dashed") - ecs_stack_1
iam - Edge(style="dashed") - s3
# diagram.py
from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.ibm.compute import Internet
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
with Diagram("Web Service", show=False):
Internet("WWW") >> EC2("web") >> RDS("userdb")
# diagram.py
from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
with Diagram("Web Service", show=False):
ELB("lb") >> EC2("web") >> RDS("userdb")
show=False,
filename='aws',
outformat='png'):
with Cluster('Amazon Web Services'):
with Cluster('Virtual Private Cloud'):
kube = EKS('Elastic Kubernetes\nService')
instance_1 = EC2('EC2 Instance 1\n(m5.xlarge)')
disk_1 = EBS('EBS Disk 1\n(gp2)')
instance_2 = EC2('EC2 Instance 2\n(m5.xlarge)')
disk_2 = EBS('EBS Disk 2\n(gp2)')
instance_1 - disk_1
instance_2 - disk_2
kube - instance_1
kube - instance_2
kube - RDS('Amazon RDS\nfor PostgreSQL\n(db.t3.large)')
kube - S3('S3')
kube - Cloudwatch('Amazon CloudWatch')
dns = Route53('Route53')
lb = ELB('Elastic Load Balancer')
lb >> kube
dns >> lb
[Client('SDKs'), Users('Users')] >> dns
with Diagram('Google Cloud Platform resources',
show=False,
filename='gke',
outformat='png'):
with Cluster('Google Cloud Platform'):
workers = [EC2(f"worker#{i}") for i in range(start, end)]
cluster >> Edge(color="pink", style="dashed",
label="Container Instance") >> workers
return cluster
with Diagram("Cluster Integration",
show=False,
direction="TB",
outformat="png",
filename="/output/grouped_workers"):
with Cluster("Other AWS Resources"):
primary_load_balancer = ELB("Load Balancer")
events_database = RDS("Events Databse")
with Cluster("Primary ECS Cluster"):
primary_cluster = create_ecs_cluster(start=0, end=7)
with Cluster("Backup Clusters"):
with Cluster("First Backup ECS Cluster"):
backup_cluster1 = create_ecs_cluster(start=10, end=12)
with Cluster("Second Backup ECS Cluster"):
backup_cluster2 = create_ecs_cluster(start=20, end=21)
primary_cluster >> events_database
backup_cluster1 >> events_database
backup_cluster2 >> events_database
primary_load_balancer >> primary_cluster
from diagrams.aws.compute import ECS
from diagrams.aws.database import RDS
from diagrams.gcp.database import BigTable
from diagrams.aws.network import ELB
from diagrams.aws.integration import SQS
from diagrams.gcp.analytics import Dataflow
with Diagram("Ruler AI", show=True):
lb = ELB("lb")
game_server = ECS("Game Server")
ai_server = ECS("AI Server")
commands = BigTable("Commands")
with Cluster("DB Cluster"):
redis = RDS("NPC State")
with Cluster("Backend Server"):
with Cluster("Writer"):
state_flow = Dataflow("Collector")
game_server >> lb >> state_flow >> redis
with Cluster("Reader"):
planner = Dataflow("Planner")
redis >> planner
ai_server >> planner >> ai_server
planner >> commands
# game_server >> planner >> game_server
with Diagram("Ruler AI Proactive", show=True):
lb = ELB("lb")
