def workflow_final():
with Diagram("",
outformat='png',
filename='images/diagrams/workflow_final',
show=False,
graph_attr=DIAGRAM_ATTR,
node_attr={
'margin': "5",
}
# direction="TB",
):
Users(f'"{random.randrange(0,1000)} Hackers"', **COMMON_NODE_ATTR) \
>> get_diagram_edge() \
>> [
EC2("server", **COMMON_NODE_ATTR),
EC2("server", **COMMON_NODE_ATTR),
EC2("server", **COMMON_NODE_ATTR),
] \
>> get_diagram_edge() \
>> Splunk("", **COMMON_NODE_ATTR) \
>> get_diagram_edge() \
>> SimpleStorageServiceS3("Public S3 Bucket", **COMMON_NODE_ATTR) \
>> get_diagram_edge() \
<< EC2("server", **COMMON_NODE_ATTR) \
>> get_diagram_edge() \
>> Firewall("IPTables", fillcolor='red', **COMMON_NODE_ATTR)
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 test_node_as_cluster(self):
with Diagram(name=os.path.join(self.name, "test_node_as_cluster"),
show=False) as d1:
node1 = Node("node1")
with EC2("node-as-cluster") as c1:
node2 = Node("node2")
self.assertEqual(c1, getcluster())
def generate_architecture_diagram():
# Use a much higher resolution than default
graph_attr = {'dpi': '240'}
with Diagram("",
show=False,
direction="TB",
graph_attr=graph_attr,
filename="simulation_server"):
with Cluster(""):
with Cluster(""):
www = APIGateway("WWW")
ws = DirectConnect("WebSocket")
udp = AppMesh("UDP")
server = EC2("Server")
server - [udp, www, ws]
browser = Client("Browser")
www >> browser
ws >> browser
ws << browser
device = AppServiceMobile("Device")
udp >> device
udp << device
def create_ecs_cluster(start, end):
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
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 import Diagram
from diagrams.aws.compute import EC2
with Diagram("Simple Diagram", show=False):
EC2("web")
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 Diagram, Cluster
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS, Database
from diagrams.aws.network import ELB
from diagrams.oci.monitoring import Queue
from diagrams.onprem.database import MySQL
from diagrams.onprem.inmemory import Redis
from diagrams.onprem.network import Nginx, Apache, Internet
from diagrams.onprem.queue import Celery
"""
https://diagrams.mingrammer.com
"""
with Diagram("Sample", show=False):
user_web = EC2("Web")
with Cluster('WEB SERVER'):
web_server = [Apache('Web Server'), Nginx('Web Server')]
with Cluster('QUEUE'):
sever_queue = Redis('Queue Broker')
sever_queue - [Celery('Queue Worker')]
with Cluster('DATABASE'):
db_master = MySQL('Database')
# db_master - Database('Database')
with Cluster('DATABASE2'):
db_slave = MySQL('Database2')
# db_slave - Database('Database2')
user_web >> web_server >> sever_queue
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 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
with Cluster("Webservices Service"):
webservices = EC2("Webservices Tasks")
autoscalingwebservices = AutoScaling(
"Webservices docker scaling")
alarmswebservices = Cloudwatch("Service CPU Alarm")
loadbalancer >> webservices >> ecr
from diagrams.aws.network import InternetGateway, RouteTable, VPCRouter
from diagrams.aws.security import KMS, IAMRole
from diagrams.generic.network import Firewall
from diagrams.onprem.network import Internet
graph_attr = {
"pad": "0",
"bgcolor": "transparent"
}
with Diagram("template-08", show=False, direction="LR", filename="diagram-08", graph_attr=graph_attr):
internet = Internet("Public Internet")
with Cluster("Vpc 10.0.0.0/16"):
internet_gateway = InternetGateway("Igw")
internet - internet_gateway
routeTable = RouteTable("RouteTable")
routeTable >> Edge(label="0.0.0.0/0", style="dashed") >> internet_gateway
with Cluster("Subnet 10.0.0.0/24"):
router = VPCRouter("Router\n10.0.0.1")
router - Edge(style="dashed") - routeTable
router - internet_gateway
ec2 = EC2("ec2\n10.0.0.x")
ec2 - Edge(style="dashed") - router
sg = Firewall("SG: 22/tcp")
ec2 - sg - router
KMS("KeyPair") - ec2
ec2Role = IAMRole("Ec2InstanceRole") - ec2
cw = Cloudwatch("CloudWatch")
cw - internet
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.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
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
core - GCS('Object Storage')
lb = LoadBalancing('Load Balancer')
dns = DNS('DNS')
lb >> ing
dns >> lb
[Client('SDKs'), Users('Users')] >> dns
with Diagram('Amazon Web Services resources',
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
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
from diagrams.aws.storage import S3
from diagrams.onprem.network import Traefik
from diagrams.custom import Custom
from diagrams.onprem.tracing import Jaeger
from diagrams.onprem.database import Cassandra
with Diagram("OpenFlow Basic"):
with Cluster("Backend"):
b = [Mongodb("MongoDB"), Rabbitmq("RabbitMQ")]
with Cluster("Remote Clients"):
rc = [Custom("OpenRPA", "./my_resources/open_rpa128.png"), Custom("PowerShell",
"./my_resources/PowerShell_5.0_icon.png"), Custom("NodeRED", "./my_resources/node-red-icon.png")]
with Cluster("Frontend + API"):
api = EC2("WEB-API")
Custom("NodeRED", "./my_resources/node-red-icon.png")
b << api
api << rc
with Diagram("OpenFlow with Traefik"):
with Cluster("Backend"):
b = [Mongodb("MongoDB"), Rabbitmq("RabbitMQ")]
with Cluster("Remote Clients"):
rc = [Custom("OpenRPA", "./my_resources/open_rpa128.png"), Custom("PowerShell",
"./my_resources/PowerShell_5.0_icon.png"), Custom("NodeRED", "./my_resources/node-red-icon.png")]
with Cluster("Frontend + API"):
api = EC2("WEB-API")
# 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")
from diagrams import Cluster, Diagram
from diagrams.aws.compute import 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")
tepDevice = Client("")
with Cluster("Dept"):
with Cluster("Department Staff"):
dsUser = User("")
dsDevice = Client("")
with Cluster("Department SAML SSO"):
tradicionalServer = TradicionalServer("")
genericSamlToken = GenericSamlToken("")
with Cluster("AWS Cloud"):
simpleEmailServiceSes = SimpleEmailServiceSes("Simple Email Service")
with Cluster("Jira"):
jELB = ElasticLoadBalancing("Load Balancer")
jEC2 = EC2("EC2 Instance")
jEBS = EBS("EBS Volume")
jRDS = RDS("Relational Database Service for Postgres")
with Cluster("Confluence"):
cELB = ElasticLoadBalancing("Load Balancer")
cECS = ECS("EC2 Instance")
cEBS = EBS("EBS Volume")
cRDS = RDS("Relational Database Service for Postgres")
#STEP2:set up relationships
dsDevice >> Edge() >> tradicionalServer
dsDevice >> Edge() >> genericSamlToken
jELB >> Edge() >> jEC2
jEC2 >> Edge() >> jRDS
jEC2 >> Edge() >> jEBS
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 Cluster("Kubernetes cluster"):
autoscaling_group = AutoScaling("Autoscaling group")
autoscaling_group_instances = [
EC2("K8s worker zone a"),
EC2("K8s worker zone b"),
EC2("K8s worker zone c"),
EC2("K8s worker zone d"),
]
ingress = Ingress("Ingress gateway")
services = Service("Services")
pods = Pod("Container pods")
ci_pipeline = GitlabCI("CI pipeline")
terraform_repo = Terraform("Infra as code")
remote_state = S3("Remote state")
ssl_certificate - dns_name
dns_name - load_balancer
load_balancer - public_subnets
from diagrams import Diagram
from diagrams.aws.compute import EC2
with Diagram("Sample Diagram"):
EC2("Web")
# 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 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.onprem.inmemory import Redis
from diagrams.onprem.monitoring import Prometheus, Grafana
from diagrams.onprem.network import Internet
from diagrams.onprem.queue import Kafka
from other import Infinispan, Ibmmq
with Diagram("Web services infrastructure Diagram", show=False, direction='TB'):
user = User("User")
support = User("Support")
internet = Internet("Internet")
with Cluster("Own infrastructure"):
load_balancer = ELB("Load Balancer")
with Cluster("service node\n(Datacenter 'DC1')"):
service1 = EC2("Server node 1\n(Scala)")
infinispan1 = Infinispan("Distributed node cache\n(Infinispan)")
with Cluster("service node\n(Datacenter 'DC2')"):
service2 = EC2("Server node 2\n(Scala)")
infinispan2 = Infinispan("Distributed node cache\n(Infinispan)")
service1 >> infinispan1
service2 >> infinispan2
prometheus = Prometheus("Prometheus")
grafana = Grafana("Grafana")
prometheus >> service1
prometheus >> service2
grafana >> prometheus
support >> grafana
"""
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
