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 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 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 test4():
filename = os.path.join(img_dir, sys._getframe().f_code.co_name)
with Diagram("Event Processing", show=False, filename=filename):
source = EKS("k8s source")
with Cluster("Event Flows"):
with Cluster("Event Workers"):
workers = [ECS("worker1"), ECS("worker2"), ECS("worker3")]
queue = SQS("event queue")
with Cluster("Processing"):
handlers = [Lambda("proc1"), Lambda("proc2"), Lambda("proc3")]
store = S3("events store")
dw = Redshift("analytics")
source >> workers >> queue >> handlers
handlers >> store
handlers >> dw
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, Cluster
from diagrams.aws.compute import EC2, ECS
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB, VPC, TransitGateway
with Diagram("vpc", show=False, direction="TB") as diag:
with Cluster("VPC"):
with Cluster(f"Private Subnet 1"):
ECS("ECS Cluster (e.g.)")
with Cluster(f"Private Subnet 2"):
ec2 = EC2("EC2 Instance (e.g.)")
ec2
with Cluster(f"Public Subnet 1") as publicnet1:
nat = TransitGateway("NAT Gateway")
igw = TransitGateway("Internet Gateway")
nat
igw
with Cluster(f"Public Subnet 2") as publicnet2:
pass
# ec2 >> nat
# ecs >> nat
# nat >> igw
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 Cluster, Diagram
from diagrams.aws.compute import ECS, EKS, Lambda
from diagrams.aws.database import Redshift
from diagrams.aws.integration import SQS
from diagrams.aws.storage import S3
with Diagram("Event Processing", show=False):
source = EKS("k8s source")
with Cluster("Event Flows"):
with Cluster("Event Workers"):
workers = [ECS("worker1"), ECS("worker2"), ECS("worker3")]
queue = SQS("event queue")
with Cluster("Processing"):
handlers = [Lambda("proc1"), Lambda("proc2"), Lambda("proc3")]
store = S3("events store")
dw = Redshift("analytics")
source >> workers >> queue >> handlers
handlers >> store
handlers >> dw
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
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
gsIamUser = IdentityAndAccessManagementIamAWSSts("AWS IAM User")
gsServer = TradicionalServer("MacOS Build Server")
with Cluster("Internet"):
with Cluster("Github"):
genericSamlToken = GenericSamlToken("oAuth Authentication Provider")
codeRepo = Storage("Code Repositories")
with Cluster("Application Developers"):
adUser = User(" ")
with Cluster("AWS Cloud"):
with Cluster("Jenkins CI/CD Pipeline"):
jcpELB = ElasticLoadBalancing("Load Balancer")
with Cluster("Jenkins Service"):
jsECS = ECS("ECS Container")
with Cluster("Jenkins Agent Workers"):
jawECS1 = ECS("ECS Container")
jawECS2 = ECS("ECS Container")
jawECS3 = ECS("ECS Container")
with Cluster("Shared Storage"):
ssEFS = ElasticFileSystemEFS("EFS FileSystem")
with Cluster("Product Accounts"):
with Cluster("AWS Account"):
aaCloud = Cloudformation("CloudFormation")
aaCli = CommandLineInterface("AWS Cli")
aaDpA = ConsoleMobileApplication("Deployed Application")
with Cluster("Sentry Exception Monitoring"):
semELB = ElasticLoadBalancing("Load Balancer")
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")
from diagrams.aws.ml import Sagemaker
from diagrams.aws.network import APIGateway
from diagrams.aws.storage import S3
from diagrams.onprem.analytics import Spark
from diagrams.onprem.client import User
from diagrams.onprem.compute import Server
from diagrams.onprem.network import Internet
with Diagram(name="", show=False, direction="LR",
filename="setup/architecture",
graph_attr={"dpi": "300"}) as diag:
with Cluster("Source"):
source = Server("HTTP")
with Cluster("Data load"):
storage = S3("Data storage")
download = ECS("ECS download task")
unzip_trigger = Lambda("S3 event trigger")
unzip = ECS("ECS unzip task")
with Cluster("Data processing"):
parse = Glue("Glue Spark XML\nparser")
catalog = GlueDataCatalog("Data Catalog")
with Cluster("Feature engineering"):
train_features = Glue("Glue Spark job:\ntrain features")
predict_features = Glue("Glue Spark job:\nprediction features")
prediction_db = Dynamodb("Prediction database")
with Cluster("ML model"):
cluster = EMRCluster("EMR Cluster")
model_fit = Spark("Spark + MLeap")
model = Sagemaker("Sagemaker endpoint")
with Cluster("Serving"):
app = Internet("Web app")
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")
dns >> lb >> svc_group
svc_group >> db_master
svc_group >> memcached
diagram_name = "Event Processing"
with Diagram(diagram_name, show=False, filename="diagrams/" + diagram_name):
source = EKS("k8s source")
cawApi = APIGateway("API Gateway")
cawLambda = Lambda("Lambda")
with Cluster("Config Web App"):
cwaCloudFront = CloudFront("CloudFront")
cwaS3 = S3("S3 Bucket")
with Cluster("Archive"):
with Cluster("Analyst Web App"):
awaCloudFront = CloudFront("CloudFront")
awaS3 = S3("S3 Bucket")
with Cluster("Data Management"):
with Cluster("AV Scanning"):
asSQS = SQS("SQS Queue")
asECS = ECS("ECS Container")
with Cluster("Data Validation"):
dvSQS = SQS("SQS Queue")
dvECS = ECS("ECS Container")
with Cluster("Data Quarantine"):
dqS3 = S3("S3 Bucket")
sns = SimpleNotificationServiceSns("SNS Notification")
#couldn't find icons
snsEmail1 = Blank("")
snsEmail2 = Blank("")
with Cluster("Data Archive"):
daS3 = S3("S3 Bucket")
#! /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")
with Cluster("ECR-Source Module"):
ecr = ECR("ECR Repository")
with Cluster("Pipeline Module"):
pipeline_source = Codepipeline("ECR Source")
pipeline_dev = Codepipeline("Deploy to\nDev")
pipeline_approval_staging = User("Manual\nApproval")
pipeline_staging = Codepipeline("Deploy to\nStaging")
pipeline_approval_prod = User("Manual\nApproval")
pipeline_prod = Codepipeline("Deploy to\nProd")
with Cluster("Development AWS Account"):
with Cluster("Service Module"):
cfn_dev = Cloudformation("CloudFormation\nStack")
with Cluster("CloudFormation Resources"):
ecs_dev = ECS("ECS Service")
task_dev = Compute("ECS Tasks")
with Cluster("Staging AWS Account"):
with Cluster("Service Module"):
cfn_staging = Cloudformation("CloudFormation\nStack")
with Cluster("CloudFormation Resources"):
ecs_staging = ECS("ECS Service")
task_staging = Compute("ECS Tasks")
with Cluster("Production AWS Account"):
with Cluster("Service Module"):
cfn_prod = Cloudformation("CloudFormation\nStack")
with Cluster("CloudFormation Resources"):
ecs_prod = ECS("ECS Service")
task_prod = Compute("ECS Tasks")
from socket import has_dualstack_ipv6
from diagrams import Cluster, Diagram
from diagrams.aws.database import RDS
from diagrams.aws.compute import ECS, EKS, Lambda
from diagrams.aws.database import Redshift
from diagrams.aws.integration import SQS
with Diagram("axie diagrams", show=False):
source = EKS("多开管理器")
source2 = EKS("多开管理器")
with Cluster("Axie 事件处理"):
with Cluster("多开管理器"):
accounts = [ECS("账号1"), ECS("账号2"), ECS("账号3")]
with Cluster("通过游戏API获取当前游戏进行状态和数据"):
state = SQS("游戏状态")
data = RDS("游戏数据")
info = [state, data]
with Cluster("多进程YOLO服务 根据规则和AI\n获得点击位置"):
handlers = [Lambda("proc1"), Lambda("proc2"), Lambda("proc3")]
click_operate = Redshift("执行点击操作")
source >> accounts >> state
accounts >> data
data >> handlers
state >> handlers
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
cELB >> Edge() >> cRDS
cECS >> Edge() >> cEBS
jEC2 >> Edge() >> simpleEmailServiceSes
cECS >> Edge() >> simpleEmailServiceSes
tepDevice >> Edge() >> jELB
tepDevice >> Edge() >> cELB
with Cluster("AWS"):
with Cluster("route53"):
route53NingenmeNet = Route53("ningenme.net")
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")
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
with Cluster("Webservices Service"):
webservices = EC2("Webservices Tasks")
autoscalingwebservices = AutoScaling(
"Webservices docker scaling")
with Cluster("Observer"):
oUser = User("")
oDevice = Mobile("")
with Cluster("Dept"):
with Cluster("Department Staff"):
dsUser = User("")
dsDevice = Client("")
with Cluster("AWS Cloud"):
with Cluster("Mobile Updates"):
s3 = S3("S3 Bucket")
with Cluster("Management App"):
elb = ElasticLoadBalancing("Load Balancer")
maECS = ECS("ECS Container")
with Cluster("Search and Reporting"):
ELS = ElasticsearchService("ElasticSearch")
cognito = Cognito("Cognito")
with Cluster("Management Services"):
msECS1 = ECS("ECS Container")
msECS2 = ECS("ECS Container")
simpleEmailServiceSes = SimpleEmailServiceSes(
"Simple Email Service")
with Cluster("Management Database"):
elasticacheForRedis = Elasticache("Elasticache for Redis")
mdRDS = RDS("Relational Database Service for Postgres")
from diagrams.aws.database import RDS
from diagrams.aws.integration import SNS
from diagrams.aws.management import Cloudwatch
from diagrams.aws.network import APIGateway
from diagrams.onprem.compute import Server
from diagrams.onprem.client import User
with Diagram("BLT Kata final container diagram", show=True):
payment_gw = Server("Payment Gateway")
customer = User("Customer")
marketing = User("Marketing")
with Cluster("System"):
with Cluster("Promotions"):
promotions_cms = ECS("CMS")
promotions_gw = APIGateway("Promotions API")
promotions_be = Lambda("Promotions BE")
promotions_cms >> promotions_gw >> promotions_be
with Cluster("In Store"):
printer_fe = S3("Docket Printer Front-end")
docket_printer = Server("Docket Printer")
cashier = User("Cashier")
store_fe = S3("Store Front-end")
store_api = APIGateway("Store API")
store_be = Lambda("Store BE")
cashier >> Edge(label="Retrieve printed docket") >> docket_printer
printer_fe >> docket_printer
store_db = S3("Store DB")
cashier >> store_fe >> store_api >> store_be >> store_db
from diagrams import Diagram, Cluster
from diagrams.aws.compute import ECS, AutoScaling
from diagrams.aws.network import APIGateway, CloudMap
with Diagram("AWS ECS Cluster", show=False, direction="TB"):
api_gw = APIGateway("api gateway")
with Cluster("vpc"):
api_gw >> CloudMap("service discovery") >> ECS(
"ecs cluster") >> AutoScaling("capacity provider")
from diagrams.onprem.logging import FluentBit
from diagrams.onprem.queue import Kafka
from diagrams.onprem.analytics import Spark
from diagrams.onprem.network import Nginx
from diagrams.onprem.monitoring import Grafana, Prometheus
from diagrams.azure.database import BlobStorage
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")
#!/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 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
from diagrams.aws.integration import SQS
from diagrams.aws.storage import S3
with Diagram("ASIF TFP CREDIT CONSTRAINT",
show=False,
filename="IMAGES/IMAGES/asif_tfp_credit_constraint",
outformat="jpg"):
temp_1 = S3('china_city_code_normalised')
temp_2 = S3('china_city_sector_pollution')
temp_3 = S3('china_city_reduction_mandate')
temp_4 = S3('china_city_tcz_spz')
temp_5 = S3('ind_cic_2_name')
temp_6 = S3('province_credit_constraint')
temp_7 = S3('china_credit_constraint')
temp_8 = ECS('asif_firms_prepared')
temp_9 = SQS('asif_tfp_firm_level')
with Cluster("FINAL"):
temp_final_1 = Redshift('asif_tfp_credit_constraint')
temp_final_1 << temp_1
temp_final_1 << temp_2
temp_final_1 << temp_3
temp_final_1 << temp_4
temp_final_1 << temp_5
temp_final_1 << temp_6
temp_final_1 << temp_7
temp_1 >> temp_8 >> temp_9 >> temp_final_1
from diagrams import Diagram
from diagrams.aws.compute import Lambda, ECS
from diagrams.aws.devtools import Codebuild
from diagrams.aws.integration import Eventbridge
from diagrams.aws.database import Dynamodb, Timestream
from diagrams.onprem.client import User
with Diagram("SLO Infrastructure", direction="TB"):
ci = Codebuild("CI/CD")
producer = Eventbridge("Event Bus")
function = Lambda("Event Handler")
event_store = Dynamodb("EventStore")
series_store = Timestream("SLO/Events")
stores = [event_store, series_store]
grafana = ECS("Dashboard")
user = User()
ci >> producer >> function >> stores
user >> grafana >> series_store
from diagrams import Cluster, Diagram
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):
from diagrams import Cluster, Diagram
from diagrams.aws.compute import ECS
from diagrams.aws.database import ElastiCache, RDS, DDB
from diagrams.aws.network import ELB
from diagrams.aws.network import Route53
with Diagram("test", show=False, filename="/imgs/test"):
dns = Route53("dns")
lb = ELB("lb")
with Cluster("ECS"):
svc_group = [ECS("svc1"), ECS("svc2"), ECS("svc3")]
with Cluster("DynamoDB"):
db_master = DDB("tableName")
dns >> lb >> svc_group
svc_group >> db_master
