156 lines
4.7 KiB
Python
156 lines
4.7 KiB
Python
import sys
|
|
from constants import *
|
|
from hcloud import Client
|
|
from hcloud.locations.domain import Location
|
|
from hcloud.networks.domain import NetworkSubnet
|
|
from hcloud.images.domain import Image
|
|
from hcloud.server_types.domain import ServerType
|
|
from hcloud.load_balancer_types.domain import LoadBalancerType
|
|
from hcloud.load_balancers.domain import LoadBalancerAlgorithm
|
|
from hcloud.load_balancers.domain import LoadBalancerService
|
|
from hcloud.load_balancers.domain import LoadBalancerServiceHttp
|
|
from hcloud.load_balancers.domain import LoadBalancerHealthCheck
|
|
from hcloud.load_balancers.domain import LoadBalancerHealtCheckHttp
|
|
from hcloud.load_balancers.domain import LoadBalancerTarget
|
|
|
|
with open(SSH_KEY_FNAME, "r") as file:
|
|
ssh_key_text = file.read()
|
|
|
|
with open(CLOUD_INIT_FNAME, "r") as file:
|
|
cloud_init = file.read()
|
|
|
|
if len(sys.argv) < 2:
|
|
raise ValueError("API key must be provided as an argument!")
|
|
|
|
client = Client(
|
|
token=str(sys.argv[1])
|
|
)
|
|
|
|
# ssh key
|
|
if client.ssh_keys.get_by_name(SSH_KEY_NAME):
|
|
ssh_key = client.ssh_keys.get_by_name(SSH_KEY_NAME)
|
|
else:
|
|
ssh_key = client.ssh_keys.create(name=SSH_KEY_NAME, public_key=ssh_key_text)
|
|
|
|
print(f"Klucz {ssh_key.data_model.name} został utworzony.")
|
|
|
|
# network
|
|
if client.networks.get_by_name(VNET_NAME):
|
|
vnet = client.networks.get_by_name(VNET_NAME)
|
|
else:
|
|
vnet = client.networks.create(
|
|
name=VNET_NAME,
|
|
ip_range=IP_RANGE,
|
|
subnets=[
|
|
NetworkSubnet(ip_range=IP_RANGE, network_zone=NETWORK_ZONE, type=NETWORK_TYPE)
|
|
]
|
|
)
|
|
|
|
print(f"Utworzono sieć wirtualną: {vnet.data_model.name} ({vnet.data_model.ip_range})")
|
|
|
|
# webservice_1
|
|
if(client.servers.get_by_name(SERVER_NAME_1)):
|
|
webservice_1 = client.servers.get_by_name(SERVER_NAME_1)
|
|
else:
|
|
webservice_1_response = client.servers.create(
|
|
name=SERVER_NAME_1,
|
|
server_type=ServerType(MACHINE_TYPE),
|
|
image=Image(name=MACHINE_OS),
|
|
ssh_keys=[ssh_key],
|
|
networks=[vnet],
|
|
location=Location(LOCATION),
|
|
user_data=cloud_init
|
|
)
|
|
webservice_1_response.action.wait_until_finished()
|
|
webservice_1 = webservice_1_response.server
|
|
|
|
print(f"Utworzono webservice 1: {webservice_1.data_model.name} ({webservice_1.data_model.public_net.ipv4.ip})")
|
|
|
|
# webservice_2
|
|
if(client.servers.get_by_name(SERVER_NAME_2)):
|
|
webservice_2 = client.servers.get_by_name(SERVER_NAME_2)
|
|
else:
|
|
webservice_2_response = client.servers.create(
|
|
name=SERVER_NAME_2,
|
|
server_type=ServerType(MACHINE_TYPE),
|
|
image=Image(name=MACHINE_OS),
|
|
ssh_keys=[ssh_key],
|
|
networks=[vnet],
|
|
location=Location(LOCATION),
|
|
user_data=cloud_init
|
|
)
|
|
webservice_2_response.action.wait_until_finished()
|
|
webservice_2 = webservice_2_response.server
|
|
|
|
print(f"Utworzono webservice 2: {webservice_2.data_model.name} ({webservice_2.data_model.public_net.ipv4.ip})")
|
|
|
|
# load balance service health check http
|
|
lb_health_check_http = LoadBalancerHealtCheckHttp(
|
|
path="/factors/10",
|
|
status_codes=["2??", "3??"],
|
|
tls=False,
|
|
)
|
|
|
|
# load balance service health check
|
|
lb_health_check = LoadBalancerHealthCheck(
|
|
protocol="http",
|
|
port="8080",
|
|
interval=10,
|
|
timeout=6,
|
|
retries=3,
|
|
http=lb_health_check_http
|
|
)
|
|
|
|
# load balance http
|
|
lb_service_http = LoadBalancerServiceHttp(
|
|
cookie_name="HCLBSTICKY",
|
|
cookie_lifetime="300",
|
|
certificates=[],
|
|
redirect_http=False,
|
|
sticky_sessions=False,
|
|
)
|
|
|
|
# load balancer service
|
|
lb_service = LoadBalancerService(
|
|
protocol="http",
|
|
listen_port="8080",
|
|
destination_port="8080",
|
|
proxyprotocol=False,
|
|
health_check=lb_health_check,
|
|
http=lb_service_http
|
|
)
|
|
|
|
# webservice_1 target
|
|
webservice_1_target = LoadBalancerTarget(
|
|
type="server",
|
|
server=webservice_1,
|
|
use_private_ip=True
|
|
)
|
|
|
|
# webservice_2 target
|
|
webservice_2_target = LoadBalancerTarget(
|
|
type="server",
|
|
server=webservice_2,
|
|
use_private_ip=True
|
|
)
|
|
|
|
# load balancer
|
|
if(client.load_balancers.get_by_name(LOAD_BALANCER_NAME)):
|
|
load_balancer = client.load_balancers.get_by_name(LOAD_BALANCER_NAME)
|
|
else:
|
|
load_balancer_response = client.load_balancers.create(
|
|
name=LOAD_BALANCER_NAME,
|
|
load_balancer_type=LoadBalancerType(name=LB_TYPE),
|
|
location=Location(LOCATION),
|
|
algorithm=LoadBalancerAlgorithm(LOAD_BALANCER_ALG),
|
|
services=[lb_service],
|
|
targets=[webservice_1_target, webservice_2_target],
|
|
public_interface=True,
|
|
network=vnet
|
|
)
|
|
load_balancer_response.action.wait_until_finished()
|
|
load_balancer = client.load_balancers.get_by_name(LOAD_BALANCER_NAME)
|
|
|
|
print(f"Utworzono load balancer: {load_balancer.data_model.name} ({load_balancer.data_model.public_net.ipv4.ip}:8080)")
|
|
|