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")