def linking_nodes_diagram():
from diagrams import Diagram, Cluster
from diagrams.aws.compute import EC2
from diagrams.aws.network import ELB
from diagrams.aws.network import Route53
from diagrams.onprem.database import PostgreSQL # Would typically use RDS from aws.database
from diagrams.onprem.inmemory import Redis # Would typically use ElastiCache from aws.database
with Diagram(
"Simple Website Diagram", direction='LR'
) as diag4: # It's LR by default, but you have a few options with the orientation
dns = Route53("DNS")
load_balancer = ELB("Load Balancer")
database = PostgreSQL("User Database")
cache = Redis("Cache")
with Cluster("Webserver Cluster"):
svc_group = [
EC2("Webserver 1"),
EC2("Webserver 2"),
EC2("Webserver 3")
]
dns >> load_balancer >> svc_group
svc_group >> cache
svc_group >> database
print(
diag4
) # This will illustrate the diagram if you are using a Google Colab or Jypiter notebook.
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 nodes_diagram():
with Diagram("Simple Website Diagram") as diag2:
dns = Route53("dns")
load_balancer = ELB("Load Balancer")
database = PostgreSQL("User Database")
cache = Redis("Cache")
svc_group = [
EC2("Webserver 1"),
EC2("Webserver 2"),
EC2("Webserver 3")
]
print(
diag2
) # This will illustrate the diagram if you are using a Google Colab or Jypiter notebook.
def main():
with Diagram("Recipeify Architecture", direction='LR'):
with Cluster("Github"):
ci = Github("Actions CI/CD")
Github("Open Source Repo") >> ci
with Cluster("Cloudfare"):
clf = Cloudflare("CDN\n DDoS Protection")
with Cluster("AWS", direction='LR'):
with Cluster("VPC"):
elb = ELB("Elastic Load Balancer")
eb = EB("Elastic Beanstalk")
es = ES("Elasticsearch")
lmda = Lambda("Lambda")
ecr = ECR("Container Registry")
with Cluster("3rd Party SaaS", direction='LR'):
with Cluster("MongoDB Atlas"):
mongo = MongoDB("Users DB")
with Cluster("Recombee"):
rec = Recombee("Recommendation\n Engine")
with Cluster("Auth0"):
auth = Auth0("Oauth2 Integrator")
with Cluster("Cloudinary"):
cl = Cloudinary("Image Caching\n and Proccessing")
auth >> Edge(style="invis") >> mongo >> Edge(
style="invis") >> cl >> Edge(style="invis") >> rec
eb >> auth
eb >> mongo
eb >> cl
eb >> rec
eb << ecr << ci
es << lmda
clf >> elb >> eb >> es
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
def linking_nodes_diagram():
with Diagram(
"Simple Website Diagram", direction='LR'
) as diag4: # It's LR by default, but you have a few options with the orientation
dns = Route53("DNS")
load_balancer = ELB("Load Balancer")
database = PostgreSQL("User Database")
cache = Redis("Cache")
with Cluster("Webserver Cluster"):
svc_group = [
EC2("Webserver 1"),
EC2("Webserver 2"),
EC2("Webserver 3")
]
dns >> load_balancer >> svc_group
svc_group >> cache
svc_group >> database
print(
diag4
) # This will illustrate the diagram if you are using a Google Colab or Jypiter notebook.
def nodes_diagram():
from diagrams import Diagram, Cluster
from diagrams.aws.compute import EC2
from diagrams.aws.network import ELB
from diagrams.aws.network import Route53
from diagrams.onprem.database import PostgreSQL # Would typically use RDS from aws.database
from diagrams.onprem.inmemory import Redis # Would typically use ElastiCache from aws.database
with Diagram("Simple Website Diagram") as diag2:
dns = Route53("dns")
load_balancer = ELB("Load Balancer")
database = PostgreSQL("User Database")
cache = Redis("Cache")
svc_group = [
EC2("Webserver 1"),
EC2("Webserver 2"),
EC2("Webserver 3")
]
print(
diag2
) # This will illustrate the diagram if you are using a Google Colab or Jypiter notebook.
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")
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 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.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
"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")
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
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
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")
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.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")]
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")
"""
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 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")
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 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"),
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
#!/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[ ]:
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
"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")