#! /usr/bin/env python
from diagrams import Diagram, Edge
from diagrams.aws.compute import ECS
from diagrams.aws.network import ELB
from diagrams.aws.network import APIGateway as apigw
from diagrams.aws.storage import S3
with Diagram("API Gateway To S3 and ECS", show=False, direction="LR"):
lb = ELB("NLB")
api_gw = apigw("APIGW")
api_gw >> Edge(label="/") >> S3("index.html")
api_gw >> Edge(label="/images/{image}") >> S3("Images")
api_gw >> Edge(label="/{folder}/{item}") >> S3("Static")
api_gw >> Edge(label="/apis") >> lb >> ECS("ECS")
#!/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[ ]:
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 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")
from diagrams.aws.network import NATGateway
from diagrams.aws.security import ACM
from diagrams.aws.network import Route53
from diagrams.aws.compute import AutoScaling
from diagrams.aws.compute import EC2
from diagrams.k8s.network import Ingress
from diagrams.k8s.network import Service
from diagrams.k8s.compute import Pod
from diagrams.onprem.iac import Terraform
from diagrams.onprem.ci import GitlabCI
from diagrams.aws.storage import S3
with Diagram("EKS Cluster", show=False, direction="LR"):
ssl_certificate = ACM("SSL cert")
dns_name = Route53("DNS domain")
load_balancer = ELB("Load balancer")
with Cluster("Custom VPC"):
with Cluster("Public network"):
public_subnets = [
PublicSubnet("Subnet zone a"),
PublicSubnet("Subnet zone b"),
PublicSubnet("Subnet zone c"),
PublicSubnet("Subnet zone d"),
]
nat_gateway = NATGateway("NAT gateway")
with Cluster("Private network"):
private_subnets = [
PrivateSubnet("Subnet zone a"),
PrivateSubnet("Subnet zone b"),
PrivateSubnet("Subnet zone c"),
PrivateSubnet("Subnet zone d"),
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 Diagram, Cluster, Edge
from diagrams.aws.compute import ECS
from diagrams.aws.network import APIGateway, CloudMap, ELB
from diagrams.generic.blank import Blank
with Diagram("AWS ECS Service", show=False, direction="TB"):
api_gw = APIGateway("api gateway")
cloud_map = CloudMap("cloud map")
api_gw << cloud_map
with Cluster("vpc"):
target_group = ELB("target group (*)")
listener_rule = ELB("listener rule (*)")
with Cluster("ecs"):
service = ECS("ecs service")
api_gw >> service >> cloud_map
service >> listener_rule >> target_group
Blank("* 0..1")
]
with Cluster("metrics host"):
metrics = Prometheus("metrics")
alertmanager = Prometheus("alertmanager")
dashboard = Grafana("monitoring")
metrics << dashboard
metrics >> alertmanager
Ansible("ansible") >> metrics
metrics >> Edge(style="dashed",
label="ec2 read permissions") >> General("AWS API")
alertmanager >> Edge(style="dashed",
label="non-critical") >> Slack("circle-alerts")
alertmanager >> Edge(style="dashed", label="critical") >> Pushover("tbd")
ELB("metrics.circlelinux.org") >> Edge(label="TCP3000") >> dashboard
with Cluster("Cloudvider"):
cloudvider_group = [
Server("server01"),
Server("server02"),
]
with Cluster("Spry Servers"):
spry_group = [
Server("server01"),
Server("server02"),
]
metrics >> aws_group
metrics >> spry_group
metrics >> cloudvider_group
"fontsize": "45",
}
with Diagram("Zeebo-app Internet Traffic overview",
show=False,
filename="zeebo-aws-network-traffic",
outformat="png",
direction="TB",
graph_attr=graph_attr):
# Grouping step
with Cluster("VPC"):
igw = InternetGateway("IGW")
with Cluster("Public Subnet"):
with Cluster("Availability Zone A"):
alb_leg_a = ELB("elb-interface-1")
with Cluster("Availability Zone B"):
alb_leg_b = ELB("elb-interface-2")
with Cluster("Availability Zone C"):
alb_leg_c = ELB("elb-interface-3")
vpc_router = VPCRouter("Internal router")
with Cluster("Private Subnet"):
with Cluster("Availability Zone A"):
eks1 = EKS("Kubernetes node 1")
with Cluster("Availability Zone B"):
eks2 = EKS("Kubernetes node 2")
with Cluster("Availability Zone C"):
eks3 = EKS("Kubernetes node 3")
# diagram.py
from diagrams import Diagram, Cluster, Edge
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
with Cluster("metrics host"):
metrics = Prometheus("metrics")
alertmanager = Prometheus("alertmanager")
dashboard = Grafana("monitoring")
metrics << dashboard
metrics >> alertmanager
Ansible("ansible") >> metrics
metrics >> Edge(style="dashed",
label="ec2 read permissions") >> General("AWS API")
alertmanager >> Edge(style="dashed",
label="non-critical") >> Slack("rocky-alerts")
alertmanager >> Edge(style="dashed",
label="critical") >> Pushover("tbd")
ELB("metrics.rockylinux.org") >> Edge(label="TCP3000") >> dashboard
with Cluster("Cloudvider"):
cloudvider_group = [
Server("server01"),
Server("server02"),
]
with Cluster("Spry Servers"):
spry_group = [
Server("server01"),
Server("server02"),
]
metrics >> aws_group
metrics >> spry_group
metrics >> cloudvider_group
from diagrams import Cluster, Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.network import VPC, PublicSubnet, PrivateSubnet, ELB, Route53
with Diagram("Load Balancer in front of an application",
show=True,
direction="TB"):
dns = Route53("DNS")
with Cluster("VPC"):
VPC()
with Cluster("Public Subnet"):
PublicSubnet()
lb = ELB("Network\nLoad Balancer")
with Cluster("Private Subnet"):
PrivateSubnet()
svc_group = [EC2("app%s" % idx) for idx in [1, 2, 3]]
dns >> lb
lb >> svc_group
from diagrams import Cluster, Diagram, Edge
from diagrams.aws.compute import EC2, ECS
from diagrams.aws.network import ELB, Route53
from diagrams.aws.database import RDS
graph_attr = {"fontsize": "45", "bgcolor": "white"}
with Diagram("Environment-Model", show=False, graph_attr=graph_attr):
with Cluster("Production"):
dns = Route53("DNS")
lb = ELB("Load Balancer")
with Cluster("Web Cluster"):
web1 = EC2("Server 1")
web2 = EC2("Server 2")
with Cluster("Database Cluster"):
db_master = RDS("Master")
db_master - [RDS("Mirror 1"), RDS("Mirror 2")]
dns >> lb
lb >> web1 >> db_master
with Cluster("Beta Testing"):
dns = Route53("DNS")
lb = ELB("Load Balancer")
with Cluster("Web Cluster"):
web1 = EC2("Server 1")
web2 = EC2("Server 2")
with Cluster("Database Cluster"):
db_master = RDS("Master")
db_master - [RDS("Mirror 1"), RDS("Mirror 2")]
dns >> lb
lb >> web1 >> db_master
# diagram.py
from diagrams import Cluster, Diagram, Edge
from diagrams.aws.compute import EC2
from diagrams.aws.management import AutoScaling
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
with Diagram("AIK Portal diagram", show=False):
with Cluster("Availability Zone A"):
instance1 = EC2("EC2")
db1 = RDS("RDS (Master)")
instance1 - db1
with Cluster("Availability Zone B"):
instance2 = EC2("EC2")
db2 = RDS("RDS (Standy)")
instance2 - db2
autosc = AutoScaling("autoscaler")
autosc - instance1
loadbalancer = ELB("loadbalancer")
instance1 - instance2
db1 - db2
loadbalancer - instance1
loadbalancer - instance2
"bgcolor": "#E587B5"
}): # one cluster defined but with overwritten attributes
Custom("Chassis", "./resources/ovn.png")
Server("strix")
with VirtualPrivateCloud(""):
with PrivateSubnet("Private"):
with SecurityGroup("web sg"):
with AutoScalling(""):
with EC2Contents("A"):
d1 = Crio("Container")
with ServerContents("A1"):
d2 = Crio("Container")
with PublicSubnet("Public"):
with SecurityGroup("elb sg"):
lb1 = ELB()
with Region("chassis 5",
graph_attr={
"pencolor": "#60193C",
"bgcolor": "#E587B5"
}): # one cluster defined but with overwritten attributes
Custom("Chassis", "./resources/ovn.png")
Server("otus")
with VirtualPrivateCloud(""):
with PrivateSubnet("Private"):
with SecurityGroup("web sg"):
with AutoScalling(""):
with EC2Contents("A"):
d3 = Crio("Container")
with ServerContents("A1"):
d4 = Crio("Container")
from diagrams.aws.database import ElastiCache, RDS, Redshift
from diagrams.aws.network import ELB, Route53
from diagrams.aws.integration import SQS
from diagrams.aws.storage import S3
from diagrams.gcp.analytics import BigQuery, Dataflow, PubSub
from diagrams.gcp.compute import AppEngine, Functions
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")]
app_servers >> nfs
with Diagram("AWS web application", show=True):
users = Users('website/mobile users')
with Cluster("Ingress"):
dns = Route53("Route53")
with Cluster("Cloudfront CDN"):
s3_content = S3('Shared content')
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
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 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
from diagrams.onprem.network import Haproxy
from diagrams.k8s.rbac import User
from diagrams.k8s.network import Ingress
from diagrams.onprem.compute import Server
with Diagram("OpenShift 4.3 with external load balancer", show=False):
dns = Route53("DNS")
lb = ELB("External load balancer (F5 BIG-IP etc")
internallb = Haproxy("Internal load balancer")
with Cluster("Masters"):
master_group = [ECS("master1"),
ECS("master2"),
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")
"""
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
from diagrams import Cluster, Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.network import VPC, PublicSubnet, PrivateSubnet, ELB, Route53
with Diagram("Load Balancer in front of an application",
show=True,
direction="TB"):
dns = Route53("DNS")
with Cluster("VPC"):
VPC()
with Cluster("Public Subnet"):
PublicSubnet()
lb = ELB("Application\nLoad Balancer")
with Cluster("Private Subnet"):
PrivateSubnet()
svc_group = [EC2("app%s" % idx) for idx in [1, 2, 3]]
dns >> lb
lb >> svc_group
with Diagram("Simple ECS Service", show=True):
with Cluster("AWS Account"):
with Cluster("Hosted Zone\nflavio.com"):
maindomain = Route53("webservices.*.flavio.com")
secondarydomain = Route53("ws.*.flavio.com")
with Cluster("ECR"):
ecr = ECR("Webservices Image")
with Cluster("VPC"):
PrivateSubnet("Private Subnet")
with Cluster("Loadbalancing"):
loadbalancer = ELB("Loadbalancer\nEndpoint")
[maindomain, secondarydomain] >> loadbalancer
with Cluster("ECS Cluster"):
clusterecs = ECS("Webservices-Prod")
autoscalingclusterecs = AutoScaling("Cluster Scaling")
ec2 = EC2("EC2 Instances")
alarmscluster = Cloudwatch("Cluster Reserved CPU Alarm")
clusterecs >> alarmscluster >> autoscalingclusterecs >> ec2
from diagrams.aws.network import ELB
from diagrams.aws.database import Redshift
from diagrams.aws.integration import SQS
from diagrams.aws.storage import S3
from diagrams.aws.security import WAF
from diagrams.aws.database import Aurora
with Diagram("Infra as <Code> - Sistemas em paralelo", show=True):
with Cluster("Infra as <Code> - Sistemas em paralelo"):
with Cluster("Front-end"):
front_end = [
EC2("Front-end-01"),
EC2("Front-end-02"),
EC2("Front-end-03")
]
with Cluster("Back-end"):
back_end = [
EC2("Back-end-01"),
EC2("Back-end-02"),
EC2("Back-end-03")
]
waf = WAF("WAF")
db = Aurora("DB")
fe_lb = ELB("Front-end-LB")
be_lb = ELB("Back-end-LB")
waf >> fe_lb >> front_end >> be_lb >> back_end >> db
with Diagram("Deployment HLA",
filename="assets-architecture-hla",
show=False,
direction="TB"):
with Cluster("Group#1") as pe:
with Cluster("Configuration Cluster") as configServer:
configServerP = ECS("Primary")
configServerB = ECS("Backup")
configServerP - configServerB
with Cluster("VM#1"):
s1 = ECS("MicroService #A")
s2 = ECS("MicroService #B")
ELB("elb") >> s1
with Cluster("VM#2"):
s3 = [Server("S3 - A...Z")]
# Volumes
with Cluster("Files"):
volumeA = FileStorage("/files")
volumeDB = Database("/database")
# Logging
with Cluster("Logging"):
logs = FluentBit("logging")
s2 >> Edge(label="produces") >> logs
# Monitoring
from diagrams.aws.security import CertificateManager, IAM
from diagrams.aws.general import Users
from diagrams.aws.storage import S3
with Diagram("Architecture", show=False):
cw = Cloudwatch("Cloudwatch")
s3 = S3("S3")
users = Users("Users")
iam = IAM("IAM")
dns = Route53("DNS")
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
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'):
with Cluster('Virtual Private Cloud'):
kube = GKE('Google Kubernetes\nEngine')
instance_1 = ComputeEngine('VM Instance 1\n(n1-standard-4)')
disk_1 = PersistentDisk('Persistent Disk 1\n(pd-standard)')
instance_2 = ComputeEngine('VM Instance 2\n(n1-standard-4)')
# 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")
from diagrams import Diagram
from diagrams import Cluster, Diagram
from diagrams.aws.network import ELB
from diagrams.aws.compute import ECS
from diagrams.onprem.database import PostgreSQL
from diagrams.aws.database import Aurora
with Diagram("DIAGRAMA : ARQUITECTURA HORIZONTAL", show=False):
lb = ELB("API/CONETENEDOR C")
with Cluster("Database "):
master = PostgreSQL("CONTENEDOR A")
data = Aurora("DATABASE")
lb >> master >> data
with Cluster("Service"):
svc_pgadmin = ECS("PGADMIN/CONTENEDOR B")
data >> svc_pgadmin
with Cluster("Services"):
svc_flask = ECS("FLASK/CONTENEDOR D")
svc_redis = ECS("REDIS/CONTENEDOR E")
master >> svc_flask
master >> svc_redis
cluster = ECS("Primary Cluster")
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
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")
