Skyatlas API v1

Skyatlas yönetici arayüzü ile sunucu işlemleri gerçekleştirilebilir. Skyatlas API'ın sağlayabilecekleri:

Alt yapıyı tamamen otomatize etme,
Sunucu açma kapama işlemleri,
Blok depolama veya ağ servislerinin tamamını uygulama ile yönetme.

Skyatlas yönetici arayüzünden yapabilen bütün işlemler Skyatlas API ile yapabilir. Arayüzden skyatlas'ın verdiği kılavuza bakarak sunucu açmak için belli adımları tamamlamak gerekli. Aynı özelliklere sahip 1 değil de 20 tane sunucu açmak için tüm adımları tekrar yapmaya gerek yok. Böyle durumlarda API kullanarak işlemler otomatize edilir. API için OpenStack'in yayınladığı kaynak kullanılır. skyatlas API ile yapılabilen temel sunucu işlemleri:

Sunucu oluşturma,
Sunucuları detaylı listeleme,
Sunucu silme,
Sunucu update etme,
Sunucu reboot etme.

HTTP İstekleriyle Yapılabilecek İşlemler

API dökümanına hoş geldiniz. Bu dökümanda HTTP istekleriyle API'da yapılabilecek işlemler yer alıyor. API kullanabilmek için yapılabilecek adımlar aşağıdaki gibi. Bu kodları kullanmak için;

requests
json
os
time

kütüphaneleri kurulu olup koda dahil edilmelidir. Bu kütüphaneleri kurmayı ihmal etmeyin, sonra devam edin. Gerekli kütüphaneleri kurduktan sonra çeşitli izinlere sahip olmalısınız.

Login Olmak:

Kullanıcının Openstack üzerindeki özellikleri kullanabilmesi için Skyatlas tarafından iletilen erişim bilgileri ile login olması gerekir. Kullanıcı kendi hesabına api üzerinden erişmek için, kullanıcı adı, parola ve tenant id bilgilerini kullanmalıdır.

credentials = {"auth": {
    "passwordCredentials":{
        "username":"<email>",
        "password":"<password>"
    },
    "tenantId":"<tenant_id>"
}
}
response = requests.post("http://185.48.212.8:5000/v2.0/tokens", data=json.dumps(credentials), headers={"content-type":"application/json"})
response_dict = response.json()
token_id = response_dict["access"]["token"]["id"]

CODE

Login olduktan sonra API kodlarını çalıştırabilir hale geleceksiniz. Şimdi sunucu oluşturma işlemlerine geçebiliriz. Sunucu açar açmaz bunu internete çıkaramayız. Bunun için izlenmesi gereken adımlar var.

Network oluşturmak
Subnet oluşturmak
Router oluşturmak
Interface ekleme
Güvenlik kuralları ouşturma
Key pair oluşturma ve ekleme
Public ip ekleme
Instance oluşturma

Oluşturma İşlemleri

Network Oluşturmak:

Bir instance(sunucu) başlatmak ve bağlanmak için öncelikle network olışturmalıyız. Oluşturulan network ile birden fazla instance, bu network üzerinden iletişim kurabilecek. Network oluşturabilmek için aşağıdaki komutlar kullanılmalıdır:

Network name oluştururken unicode ve Türkçe karakter içermeyen bir isim kullanın.


network_dict = {
    "network": {
        "name": "<network_name>",
        "admin_state_up": True
    }
}
network_response=requests.post("http://185.48.212.8:9696/v2.0/networks",
                      headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(network_dict))

CODE

Network oluşturduktan sonra subnet oluşturma adımına geçebiliriz.

Subnet Oluşturma:

Subnet oluşturabilmek için aşağıdaki komutlar kullanılmalıdır.

Subnet oluştururken oluşturduğumuz network id'yi kullanırız.


subnet_dict = {
    "subnet": {
        "network_id": network_id,
        "name": "<subnet_name>",
        "ip_version": 4,
        "cidr": "10.0.0.1/24",
        "gateway_ip": "10.0.0.1"
    }
}
subnet_response=requests.post("http://185.48.212.8:9696/v2.0/subnets",
                              headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(subnet_dict))

CODE

Subnet oluşturduktan sonra router oluşturma adımına geçebiliriz.

Router Oluşturma:

Farklı networkteki instanceların birbirleri ile bilgi alışverişi yapmak için routera ihtiyaç vardır. Router oluşturmak için aşağıdaki komutlar kullanılmalıdır:

Dikkat edilmesi gereken nokta network id'ye external network id verilmelidir.

 router_dict = {
    "router": {
        "name": "<router_name",
        "external_gateway_info": {
            "network_id": external_network_id
        },
        "admin_state_up": True
    }
}
router_response=requests.post("http://185.48.212.8:9696/v2.0/routers",
                       headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(router_dict))

CODE

Router oluşturduktan sonra interface oluşturma adımına geçilebilir.

Interface Oluşturma:

Interface oluşturmak için aşağıdaki komutlar kullanılmalıdır:

Interface oluşturabilmek için yukarıda oluşturduğumuz subnet'in id'sini kullanırız.

interface_dict = {
    "subnet_id": subnet_id
}
interface_response = requests.put("http://185.48.212.8:9696/v2.0/routers/"+router_id+"/add_router_interface",
                        headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(interface_dict))

CODE

Oluşturulacak olan Instance'a erişmek ve bağlanmak için security group oluşturma işlemi Instance oluşturulmadan önce yapılmalı.

Security Group Oluşturma:

Security group oluşturmak için aşağıdaki komutlar kullanılmalıdır:

security_group_response=requests.get("http://185.48.212.8:9696/v2.0/security-groups",
                      headers={"x-auth-token": token_id, "content-type":"application/json"})

CODE

Sunucuların hangi portlardan erişim izni verilmesi isteniyorsa bu grup altına eklenebilir.

Kural Ekleme:

instance'ın içe ve dışa doğru erişimlerini sağlayacak kurallar ekleyebiliriz. Örneğin linux instance'lara SSH ile 22 portu üzerinden erişebilmek için SSH kuralını eklememiz gerekiyor.

rules_dict = {
    "security_group_rule": {
        "direction": "ingress",
        "port_range_min": "22",
        "ethertype": "IPv4",
        "port_range_max": "22",
        "protocol": "tcp",
        "security_group_id": security_group_id
    }
}
 
rules_response=requests.post("http://185.48.212.8:9696/v2.0/security-group-rules",
                      headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(rules_dict))

CODE

Keypair Ekleme:

Linux sunuculara güvenli bağlantı için keypair eklenmesi gerekir. Keypair eklemek için öncelikle local sistemden public key oluşturulması gerekir. Public key parametresine oluşturulan bu public key verilir. Keypair name oluştururken boşluk bırakmadan, unicode ve Türkçe karakter içermeyen isimler kullanmak dikkat edilmesi gereken nokta.

home_directory = os.getenv("HOME")
key = open(home_directory + "/.ssh/id_rsa.pub")
public_key = key.read()
 
keypair_dict = {
    "keypair": {
        "name": "<keypair_name>",
        "public_key": public_key
    }
}
keypair_response=requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/os-keypairs",
                      headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(keypair_dict))

CODE

Oluşturduğumuz keypair, public IP verilmiş bir sunucuya ssh ile bağlanmak için kullanılacaktır.

Port Oluşturma:

port_dict = {
    "port": {
        "network_id": network_id,
        "name": "<port_name>",
        "admin_state_up": True
    }
}
port_response=requests.post("http://185.48.212.8:9696/v2.0/ports",
                            headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(port_dict))

CODE

Public Ip Oluşturma:

Oluşturulacak instance internet üzerinden erişebilmek için public ip oluşturmamız gerekir. Public ip oluşturmak için aşağıdaki komutlar kullanılmalıdır:

floating_dict = {
    "floatingip": {
        "floating_network_id": external_network_id,
        "port_id": port_id
    }
}
floating_response=requests.post("http://185.48.212.8:9696/v2.0/floatingips",
                                headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(floating_dict))

CODE

Images Oluşturma:

Images oluşturarak açacağımız serverin hangi işletim sistemini kullanacağını seçiyoruz. Biz burada Ubuntu oluşturduk. İhtiyaca göre CentOS, Debian, Fedora ve Windows da kullanılabilir.

images_response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/images",
                               headers={"x-auth-token": token_id})
images = images_response.json()["images"]
 
for image in images:
    if image["name"] ==  "Ubuntu Trusty":
        image_id = image["id"]

CODE

Flavor Oluşturma:

Flavor oluştururken açacağımız serverın boyutunu belirliyoruz. S, M, L, XL ve XXL boyutlarında server oluşturabiliriz.

flavor_response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/flavors",
                               headers = {"x-auth-token": token_id})
 
flavors = flavor_response.json()["flavors"]
for flavor in flavors:
    if flavor["name"] == "General S":
        flavor_id = flavor["id"]

CODE

Server Oluşturma:

Bir sunucu oluşturmak için aşağıda görüldüğü gibi boşluk ve unicode olmayan bir server name, image id, flavor id, keypair name ve network id parametreleri verilmelidir.

server_info = {
    "server": {
        "name":"<server_name>",
      "imageRef": image_id,
      "flavorRef": flavor_id,
        "key_name": "<keypair_name>",
        "networks": [
            {
                "uuid": network_id
            }
        ]
    }
}
 
compute_response = requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers",
                                 headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(server_info))

CODE

Instance'a Public Ip Ekleme:

Bir sunucuya internet üzerinden erişebilmek için, daha önceden floating ipleri eklenen herhangi bir ip address parametresine verilir.

floating_ip_dict = {
    "addFloatingIp": {
        "address": floating_ip
    }
}
 
 
response=requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/"+server_id+"/action",
                      headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(floating_ip_dict))

CODE

Bu adımlarla SSH ile bağlanılabilecek sunucumuz oluştu.

Sıfırdan Dışarıdan Erişilebilir Sunucu Oluşturma:

Önceki başlıkta adım adım ayırdığımız işlemleri bu kısımda tek bir kodla gerçekleştirebilirsiniz.

import requests
import json
import os
import time

credentials = {"auth": {
    "passwordCredentials":{
        "username":"<email>",
        "password":"<password>"
    },
    "tenantId":"<tenant_id>"
}
}
response = requests.post("http://185.48.212.8:5000/v2.0/tokens", data=json.dumps(credentials), headers={"content-type":"application/json"})
response_dict = response.json()
token_id = response_dict["access"]["token"]["id"]
network_dict = {
    "network": {
        "name": "<network_name>",
        "admin_state_up": True
    }
}
print "Creating Network"
network_response=requests.post("http://185.48.212.8:9696/v2.0/networks",
                      headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(network_dict))

network_id = network_response.json()["network"]["id"]

subnet_dict = {
    "subnet": {
        "network_id": network_id,
        "name": "<subnet_name>",
        "ip_version": 4,
        "cidr": "10.0.0.1/24",
        "gateway_ip": "10.0.0.1"
    }
}
print "Creating Subnet"
subnet_response=requests.post("http://185.48.212.8:9696/v2.0/subnets",
                              headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(subnet_dict))

subnet_id = subnet_response.json()["subnet"]["id"]

list_network_response=requests.get("http://185.48.212.8:9696/v2.0/networks",
                      headers={"x-auth-token": token_id, "content-type":"application/json"})
networks = list_network_response.json()["networks"]
for network in networks:
    if network["router:external"]:
        external_network_id = network["id"]

router_dict = {
    "router": {
        "name": "<router_name",
        "external_gateway_info": {
            "network_id": external_network_id
        },
        "admin_state_up": True
    }
}

print "Creating Router"
router_response=requests.post("http://185.48.212.8:9696/v2.0/routers",
                       headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(router_dict))

router_id = router_response.json()["router"]["id"]

interface_dict = {
    "subnet_id": subnet_id
}
print "Creating Interface"
interface_response = requests.put("http://185.48.212.8:9696/v2.0/routers/"+router_id+"/add_router_interface",
                        headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(interface_dict))
print "Creating Security Group"
security_group_response=requests.get("http://185.48.212.8:9696/v2.0/security-groups",
                      headers={"x-auth-token": token_id, "content-type":"application/json"})
security_group_id = security_group_response.json()["security_groups"][0]["id"]

rules_dict = {
    "security_group_rule": {
        "direction": "ingress",
        "port_range_min": "22",
        "ethertype": "IPv4",
        "port_range_max": "22",
        "protocol": "tcp",
        "security_group_id": security_group_id
    }
}

rules_response=requests.post("http://185.48.212.8:9696/v2.0/security-group-rules",
                      headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(rules_dict))

home_directory = os.getenv("HOME")
key = open(home_directiry + "/.ssh/id_rsa.pub")
public_key = key.read()

keypair_dict = {
    "keypair": {
        "name": "<keypair_name>",
        "public_key": public_key
    }
}
print "Creating Keypair"
keypair_response=requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/os-keypairs",
                      headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(keypair_dict))

port_dict = {
    "port": {
        "network_id": network_id,
        "name": "<port_name>",
        "admin_state_up": True
    }
}
print "Creating Port"
port_response=requests.post("http://185.48.212.8:9696/v2.0/ports",
                            headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(port_dict))
port_id = port_response.json()["port"]["id"]


floating_dict = {
    "floatingip": {
        "floating_network_id": external_network_id,
        "port_id": port_id
    }
}
floating_response=requests.post("http://185.48.212.8:9696/v2.0/floatingips",
                                headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(floating_dict))

floating_ip = floating_response.json()["floatingip"]["floating_ip_address"]

print "Creating Images"
images_response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/images",
                               headers={"x-auth-token": token_id})
images = images_response.json()["images"]

for image in images:
    if image["name"] ==  "Ubuntu Trusty":
        image_id = image["id"]
print "Creating Flavor"
flavor_response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/flavors",
                               headers = {"x-auth-token": token_id})

flavors = flavor_response.json()["flavors"]
for flavor in flavors:
    if flavor["name"] == "General S":
        flavor_id = flavor["id"]

print "Creating Server"

server_info = {
    "server": {
        "name":"<server_name>",
      "imageRef": image_id,
      "flavorRef": flavor_id,
        "key_name": "<keypair_name>",
        "networks": [
            {
                "uuid": network_id
            }
        ]
    }
}

compute_response = requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers",
                                 headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(server_info))
server_id = compute_response.json()["server"]["id"]
server_ready = False
while not server_ready:
    time.sleep(5)
    print "Waiting for Server Ready"
    compute_detail_response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/"+server_id,
                                 headers = {"x-auth-token": token_id})
    status = compute_detail_response.json()["server"]["status"]
    server_ready = (status == "ACTIVE")


print "Creating Floating Ip"

floating_ip_dict = {
    "addFloatingIp": {
        "address": floating_ip
    }
}


response=requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/"+server_id+"/action",
                      headers={"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(floating_ip_dict))

CODE

Silme İşlemleri

Mevcutta oluşturulmuş router, network ve sunucuları silmek için aşağıdaki komut satırları çalıştırılır.

import requests
import json
import pprint

credentials = {"auth": {
    "passwordCredentials":{
        "username":"<email>",
         "password":"<password>"
      },
      "tenantId":"<tenant_id>"
      }

}
response = requests.post("http://185.48.212.8:5000/v2.0/tokens", data=json.dumps(credentials),
                         headers = {"content-type":"application/json"})
response_dict = response.json()
token_id = response_dict["access"]["token"]["id"]

response_floatingIp_list = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/os-floating-ips",
                                             headers = {"x-auth-token": token_id})
for i in response_floatingIp_list.json()["floating_ips"]:
    deallocate_floatingIp = requests.delete("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/os-floating-ips/"+i["id"],
                                             headers = {"x-auth-token": token_id, "content-type":"application/json"})

response_port_list = requests.get("http://185.48.212.8:9696/v2.0/ports",
                                  headers={"x-auth-token": token_id})
response_ports = response_port_list.json()["ports"]
response_router_list = requests.get("http://185.48.212.8:9696/v2.0/routers",
                                    headers = {"x-auth-token": token_id})
for port in response_ports:
    fixed_ips = port["fixed_ips"]
    for fixed_ip in fixed_ips:
        subnet_id = fixed_ip["subnet_id"]

        interface_dict = {
            "subnet_id": subnet_id
        }
        for router in response_router_list.json()["routers"]:
            requests.put("http://185.48.212.8:9696/v2.0/routers/"+router["id"]+"/remove_router_interface",
                                                headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(interface_dict))

for i in response_router_list.json()["routers"]:
    delete_router = requests.delete("http://185.48.212.8:9696/v2.0/routers/"+i["id"],
                                    headers={"x-auth-token": token_id, "content-type":"application/json"})
for i in response_port_list.json()["ports"]:
    delete_ports = requests.delete("http://185.48.212.8:9696/v2.0/ports/"+i["id"],
                                   headers={"x-auth-token": token_id})
    pprint.pprint(delete_ports.text)

response_subnet_list = requests.get("http://185.48.212.8:9696/v2.0/subnets",
                                  headers={"x-auth-token": token_id})

for i in response_subnet_list.json()["subnets"]:
    delete_subnet = requests.delete("http://185.48.212.8:9696/v2.0/subnets/"+i["id"],
                                   headers={"x-auth-token": token_id})
    pprint.pprint(delete_subnet.text)

response_network_list = requests.get("http://185.48.212.8:9696/v2.0/networks",
                      headers={"x-auth-token": token_id})


for i in response_network_list.json()["networks"]:
    delete_network = requests.delete("http://185.48.212.8:9696/v2.0/networks/"+i["id"],headers={"x-auth-token": token_id} )
    pprint.pprint(delete_network.text)


response_list_servers=requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers",
                      headers = {"x-auth-token": token_id})
for i in response_list_servers.json()["servers"]:
    delete_servers = requests.delete("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/"+i["id"],
                                     headers={"x-auth-token": token_id})

CODE

Sunucu Silme:

compute_response = requests.delete("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/<"sunucu_id>",
                                   headers={"x-auth-token": token_id, "content-type":"application/json"})

CODE

Listeleme İşlemleri

İmaj Listeleme:

images_response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/images",
	headers={"x-auth-token": token_id})

CODE

İstenilen Sunucuyu Detaylı Listeleme:

response=requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/<server_id>", 
	headers = {"x-auth-token": token_id})

CODE

Keypair Listeleme:

response=requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/os-keypairs",
	headers = {"x-auth-token": token_id, "content-type":"application/json"})

CODE

Flavor Listeleme:

flavor_response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/flavors",
	headers={"x-auth-token": token_id})

CODE

Network Listeleme:

response=requests.get("http://185.48.212.8:9696/v2.0/networks",
	headers = {"x-auth-token": token_id, "content-type":"application/json"})

CODE

Port Listeleme:

response_port_list = requests.get("http://185.48.212.8:9696/v2.0/ports",
    headers={"x-auth-token": token_id, "content-type":"application/json"})

CODE

Security Group Listeleme:

response=requests.get("http://185.48.212.8:9696/v2.0/security-groups",
    headers = {"x-auth-token": token_id, "content-type":"application/json"})

CODE

Sunucuları Listeleme:

response=requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/6<tenant_id>/servers", 
	headers = {"x-auth-token": token_id})

CODE

Kural Listeleme:

response=requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/6<tenant_id>/os-security-groups-default-rules",
    headers = {"x-auth-token": token_id, "content-type":"application/json"})

CODE

Sunucuların Detaylarını Listeleme:

response = requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/detail",
                      headers={"x-auth-token": token_id}) 

pprint.pprint(response.json())

CODE

İstenilen Sunucunun Detaylarını Listeleme:

response=requests.get("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/<server_id>", 
	headers = {"x-auth-token": token_id})

CODE

Güncelleme İşlemleri

Instance Güncelleme:

servers = {
    "server": {
        "name": "<yeni_isim>"
    }
}

response=requests.put("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/<server_id>", 
                 headers={"content-type":"application/json","x-auth-token": token_id}, data=json.dumps(servers))

CODE

Şifre Güncelleme:

server_info = {
    "changePassword": {
        "adminPass": "<new_password>"
    }
}

compute_response = requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/6a97dceaa064484eb2be90867684bf7b/servers/ba4fb7c8-5625-4820-aaf7-f6a01a72bb28/action", headers = {"x-auth-token": token_id, "content-type":"application/json"}, data=json.dumps(server_info))

CODE

Reboot Server:

servers = {
    "reboot": {
        "type": "SOFT"
    }
}
response=requests.post("https://compute.istanbul-1.endpoint.skyatlas.com/v2/<tenant_id>/servers/<server_id>/action", 
	headers = {"content-type":"application/json","x-auth-token": token_id}, data=json.dumps(servers))

CODE

Python Novaclient ile Temel Sunucu İşlemleri

Sunucu Oluşturma

from keystoneclient.auth.identity import v2
from keystoneclient import session
from novaclient.v2 import client
auth = v2.Password(auth_url="http://185.48.212.8:5000/v2.0",
                   username="<email>",
                   password="<password>",
                   tenant_id="<tenant_id>")
sess = session.Session(auth=auth)
nova = client.Client("http://185.48.212.8:5000/v2.0", session=sess)

fl = nova.flavors.find(ram=2048)
img = nova.images.find(name="Ubuntu Trusty")
nova.servers.create("my-server", flavor=fl, image=img)

CODE

Sunucu Silme

from keystoneclient.auth.identity import v2
from keystoneclient import session
from novaclient.v2 import client
auth = v2.Password(auth_url="http://185.48.212.8:5000/v2.0",
                   username="<email>",
                   password="<password>",
                   tenant_id="<tenant_id>")
sess = session.Session(auth=auth)
nova = client.Client("http://185.48.212.8:5000/v2.0", session=sess)
server = nova.servers.find(name="<sunucu_adı>")
server.delete()

CODE

Sunucu Listeleme

from keystoneclient.auth.identity import v2
from keystoneclient import session
from novaclient.v2 import client
auth = v2.Password(auth_url="http://185.48.212.8:5000/v2.0",
                   username="<email>",
                   password="<password>",
                   tenant_id="<tenant_id>")
sess = session.Session(auth=auth)
nova = client.Client("http://185.48.212.8:5000/v2.0", session=sess)
for i in nova.servers.list(detailed=True) :
    print i.id, i.name, i.status

CODE

Sunucu Güncelleme

from keystoneclient.auth.identity import v2
from keystoneclient import session
from novaclient.v2 import client
auth = v2.Password(auth_url="http://185.48.212.8:5000/v2.0",
                   username="<email>",
                   password="<password>",
                   tenant_id="<tenant_id>")
sess = session.Session(auth=auth)
nova = client.Client("http://185.48.212.8:5000/v2.0", session=sess)
server = nova.servers.find(name="<eski_isim>")

server.update(name="<yeni_isim>")

CODE