API 文档

API 文档默认已经集成在代码里面，部署完成后可以通过下面的方式进行访问

API 访问

VersionAccess methodexample
< 2.0.0http://<url>/docshttp://192.168.244.144/docs
>=2.0.0http://<url>/api/docs/http://192.168.244.144/api/docs/
>=2.6.0http://<url>/api/docs/http://192.168.244.144/api/docs/

版本小于 v2.6 需要打开 debug 模式

  1. vi config.yml
  1. ...
  2. # 如果版本更低的话，配置文件是 config.py
  3. # Debug = true
  4. DEBUG: true

api_swagger

API 认证

JumpServer API 支持的认证有以下几种方式

  1. Session         登录后可以直接使用 session_id 作为认证方式
  2. Token           获取一次性 Token，该 Token 有有效期, 过期作废
  3. Private Token   永久 Token
  4. Access Key      对 Http Header 进行签名

Session

用户通过页面后登录，cookie 中会存在 sessionid，请求时同样把 sessionid 放到 cookie 中

Token

  1. curl -X POST http://localhost/api/v1/authentication/auth/ \
  2.      -H 'Content-Type: application/json' \
  3.      -d '{"username": "admin", "password": "admin"}'

Python

  1. # Python 示例
  2. # pip install requests
  3. import requests, json
  5. def get_token(jms_url, username, password):
  6.     url = jms_url + '/api/v1/authentication/auth/'
  7.     query_args = {
  8.         "username": username,
  9.         "password": password
  10.     }
  11.     response = requests.post(url, data=query_args)
  12.     return json.loads(response.text)['token']
  14. def get_user_info(jms_url, token):
  15.     url = jms_url + '/api/v1/users/users/'
  16.     headers = {
  17.         "Authorization": 'Bearer ' + token,
  18.         'X-JMS-ORG': '00000000-0000-0000-0000-000000000002'
  19.     }
  20.     response = requests.get(url, headers=headers)
  21.     print(json.loads(response.text))
  23. if __name__ == '__main__':
  24.     jms_url = 'https://demo.jumpserver.org'
  25.     username = 'admin'
  26.     password = 'admin'
  27.     token = get_token(jms_url, username, password)
  28.     get_user_info(jms_url, token)

Golang

  1. // Golang 示例
  2. package main
  4. import (
  5.     "encoding/json"
  6.     "fmt"
  7.     "io/ioutil"
  8.     "log"
  9.     "net/http"
  10.     "strings"
  11. )
  13. func GetToken(jms_url, username, password string) (string, error) {
  14.     url := jms_url + "/api/v1/authentication/auth/"
  15.     query_args := strings.NewReader(`{
  16.         "username": "`+username+`",
  17.         "password": "`+password+`"
  18.     }`)
  19.     client := &http.Client{}
  20.     req, err := http.NewRequest("POST", url, query_args)
  21.     req.Header.Add("Content-Type", "application/json")
  22.     resp, err := client.Do(req)
  23.     if err != nil {
  24.         log.Fatal(err)
  25.     }
  26.     defer resp.Body.Close()
  27.     body, err := ioutil.ReadAll(resp.Body)
  28.     if err != nil {
  29.         log.Fatal(err)
  30.     }
  31.     response := map[string]interface{}{}
  32.     json.Unmarshal(body, &response)
  33.     return response["token"].(string), nil
  34. }
  36. func GetUserInfo(jms_url, token string) {
  37.     url := jms_url + "/api/v1/users/users/"
  38.     client := &http.Client{}
  39.     req, err := http.NewRequest("GET", url, nil)
  40.     req.Header.Add("Authorization", "Bearer "+token)
  41.     req.Header.Add("X-JMS-ORG", "00000000-0000-0000-0000-000000000002")
  42.     resp, err := client.Do(req)
  43.     if err != nil {
  44.         log.Fatal(err)
  45.     }
  46.     defer resp.Body.Close()
  47.     body, err := ioutil.ReadAll(resp.Body)
  48.     if err != nil {
  49.         log.Fatal(err)
  50.     }
  51.     fmt.Println(string(body))
  52. }
  54. func main() {
  55.     jms_url := "https://demo.jumpserver.org"
  56.     username := "admin"
  57.     password := "admin"
  58.     token, err := GetToken(jms_url, username, password)
  59.     if err != nil {
  60.         log.Fatal(err)
  61.     }
  62.     GetUserInfo(jms_url, token)
  63. }

Private Token

  1. docker exec -it jms_core /bin/bash
  2. cd /opt/jumpserver/apps
  3. python manage.py shell
  4. from users.models import User
  5. u = User.objects.get(username='admin')
  6. u.create_private_token()

已经存在 private_token，可以直接获取即可

  1. u.private_token

以 PrivateToken: 937b38011acf499eb474e2fecb424ab3 为例:

  1. curl -H 'Authorization: Token 937b38011acf499eb474e2fecb424ab3' \
  2.      -H "Content-Type:application/json" http://demo.jumpserver.org/api/v1/users/users/

Python

  1. # Python 示例
  2. # pip install requests
  3. import requests, json
  5. def get_user_info(jms_url, token):
  6.     url = jms_url + '/api/v1/users/users/'
  7.     headers = {
  8.         "Authorization": 'Token ' + token,
  9.         'X-JMS-ORG': '00000000-0000-0000-0000-000000000002'
  10.     }
  11.     response = requests.get(url, headers=headers)
  12.     print(json.loads(response.text))
  14. if __name__ == '__main__':
  15.     jms_url = 'https://demo.jumpserver.org'
  16.     token = '937b38011acf499eb474e2fecb424ab3'
  17.     get_user_info(jms_url, token)

Golang

  1. // Golang 示例
  2. package main
  4. import (
  5.     "encoding/json"
  6.     "fmt"
  7.     "io/ioutil"
  8.     "log"
  9.     "net/http"
  10.     "strings"
  11. )
  13. func GetUserInfo(jms_url, token string) {
  14.     url := jms_url + "/api/v1/users/users/"
  15.     client := &http.Client{}
  16.     req, err := http.NewRequest("GET", url, nil)
  17.     req.Header.Add("Authorization", "Token "+token)
  18.     req.Header.Add("X-JMS-ORG", "00000000-0000-0000-0000-000000000002")
  19.     resp, err := client.Do(req)
  20.     if err != nil {
  21.         log.Fatal(err)
  22.     }
  23.     defer resp.Body.Close()
  24.     body, err := ioutil.ReadAll(resp.Body)
  25.     if err != nil {
  26.         log.Fatal(err)
  27.     }
  28.     fmt.Println(string(body))
  29. }
  31. func main() {
  32.     jms_url := "https://demo.jumpserver.org"
  33.     token := "937b38011acf499eb474e2fecb424ab3"
  34.     GetUserInfo(jms_url, token)
  35. }

Access Key

在 Web 页面 API Key 列表创建或获取 AccessKeyID AccessKeySecret

Python

  1. # Python 示例
  2. # pip install requests drf-httpsig
  3. import requests, datetime, json
  4. from httpsig.requests_auth import HTTPSignatureAuth
  6. def get_auth(KeyID, SecretID):
  7.     signature_headers = ['(request-target)', 'accept', 'date']
  8.     auth = HTTPSignatureAuth(key_id=KeyID, secret=SecretID, algorithm='hmac-sha256', headers=signature_headers)
  9.     return auth
  11. def get_user_info(jms_url, auth):
  12.     url = jms_url + '/api/v1/users/users/'
  13.     gmt_form = '%a, %d %b %Y %H:%M:%S GMT'
  14.     headers = {
  15.         'Accept': 'application/json',
  16.         'X-JMS-ORG': '00000000-0000-0000-0000-000000000002',
  17.         'Date': datetime.datetime.utcnow().strftime(gmt_form)
  18.     }
  20.     response = requests.get(url, auth=auth, headers=headers)
  21.     print(json.loads(response.text))
  23. if __name__ == '__main__':
  24.     jms_url = 'https://demo.jumpserver.org'
  25.     KeyID = 'AccessKeyID'
  26.     SecretID = 'AccessKeySecret'
  27.     auth = get_auth(KeyID, SecretID)
  28.     get_user_info(jms_url, auth)

Golang

  1. // Golang 示例
  2. package main
  4. import (
  5.     "fmt"
  6.     "io/ioutil"
  7.     "log"
  8.     "net/http"
  9.     "time"
  10.     "gopkg.in/twindagger/httpsig.v1"
  11. )
  13. type SigAuth string {
  14.     KeyID    string
  15.     SecretID string
  16. }
  18. func (auth *SigAuth) Sign(r *http.Request) error {
  19.     headers := []string{"(request-target)", "date"}
  20.     signer, err := httpsig.NewRequestSigner(auth.KeyID, auth.SecretID, "hmac-sha256")
  21.     if err != nil {
  22.         return err
  23.     }
  24.     return signer.SignRequest(r, headers, nil)
  25. }
  27. func GetUserInfo(jms_url string, auth *SigAuth) {
  28.     url := jms_url + "/api/v1/users/users/"
  29.     gmt_fmt := "Mon, 02 Jan 2006 15:04:05 GMT"
  30.     client := &http.Client{}
  31.     req, err := http.NewRequest("GET", url, nil)
  32.     req.Header.Add("Date", time.Now().Format(gmt_fmt))
  33.     req.Header.Add("Accept", "application/json")
  34.     req.Header.Add("X-JMS-ORG", "00000000-0000-0000-0000-000000000002")
  35.     if err != nil {
  36.         log.Fatal(err)
  37.     }
  38.     if err := auth.Sign(req); err != nil {
  39.         log.Fatal(err)
  40.     }
  41.     resp, err := client.Do(req)
  42.     if err != nil {
  43.         log.Fatal(err)
  44.     }
  45.     defer resp.Body.Close()
  46.     body, err := ioutil.ReadAll(resp.Body)
  47.     if err != nil {
  48.         log.Fatal(err)
  49.     }
  50.     fmt.Println(string(body))
  51. }
  53. func main() {
  54.     jms_url := "https://demo.jumpserver.org"
  55.     auth := SigAuth{
  56.         KeyID:    "AccessKeyID",
  57.         SecretID: "AccessKeySecret",
  58.     }
  59.     GetUserInfo(jms_url, &auth)
  60. }

示例

Token

  1. #!/usr/bin/env python3
  2. # -*- coding:utf-8 -*-
  4. import sys, requests, time
  6. class HTTP:
  7.     server = None
  8.     token  = None
  10.     @classmethod
  11.     def get_token(cls, username, password):
  12.         data              = {'username': username, 'password': password}
  13.         url               = "/api/v1/authentication/auth/"
  14.         res               = requests.post(cls.server + url, data)
  15.         res_data          = res.json()
  16.         if res.status_code in [200, 201] and res_data:
  17.             token         = res_data.get('token')
  18.             cls.token     = token
  19.         else:
  20.             print("获取 token 错误, 请检查输入项是否正确")
  21.             sys.exit()
  23.     @classmethod
  24.     def get(cls, url, params=None, **kwargs):
  25.         url               = cls.server + url
  26.         headers           = {
  27.             'Authorization': "Bearer {}".format(cls.token),
  28.             'X-JMS-ORG': '00000000-0000-0000-0000-000000000002'
  29.         }
  30.         kwargs['headers'] = headers
  31.         res               = requests.get(url, params, **kwargs)
  32.         return res
  34.     @classmethod
  35.     def post(cls, url, data=None, json=None, **kwargs):
  36.         url               = cls.server + url
  37.         headers           = {
  38.             'Authorization': "Bearer {}".format(cls.token),
  39.             'X-JMS-ORG': '00000000-0000-0000-0000-000000000002'
  40.         }
  41.         kwargs['headers'] = headers
  42.         res               = requests.post(url, data, json, **kwargs)
  43.         return res
  45. class User(object):
  47.     def __init__(self):
  48.         self.id           = None
  49.         self.name         = user_name
  50.         self.username     = user_username
  51.         self.email        = user_email
  53.     def exist(self):
  54.         url               = '/api/v1/users/users/'
  55.         params            = {'username': self.username}
  56.         res               = HTTP.get(url, params=params)
  57.         res_data          = res.json()
  58.         if res.status_code in [200, 201] and res_data:
  59.             self.id       = res_data[0].get('id')
  60.         else:
  61.             self.create()
  63.     def create(self):
  64.         print("创建用户 {}".format(self.username))
  65.         url               = '/api/v1/users/users/'
  66.         data              = {
  67.             'name': self.name,
  68.             'username': self.username,
  69.             'email': self.email,
  70.             'is_active': True
  71.         }
  72.         res               = HTTP.post(url, json=data)
  73.         self.id           = res.json().get('id')
  75.     def perform(self):
  76.         self.exist()
  78. class Node(object):
  80.     def __init__(self):
  81.         self.id           = None
  82.         self.name         = asset_node_name
  84.     def exist(self):
  85.         url               = '/api/v1/assets/nodes/'
  86.         params            = {'value': self.name}
  87.         res               = HTTP.get(url, params=params)
  88.         res_data          = res.json()
  89.         if res.status_code in [200, 201] and res_data:
  90.             self.id       = res_data[0].get('id')
  91.         else:
  92.             self.create()
  94.     def create(self):
  95.         print("创建资产节点 {}".format(self.name))
  96.         url               = '/api/v1/assets/nodes/'
  97.         data              = {
  98.             'value': self.name
  99.         }
  100.         res               = HTTP.post(url, json=data)
  101.         self.id           = res.json().get('id')
  103.     def perform(self):
  104.         self.exist()
  106. class AdminUser(object):
  108.     def __init__(self):
  109.         self.id           = None
  110.         self.name         = assets_admin_name
  111.         self.username     = assets_admin_username
  112.         self.password     = assets_admin_password
  114.     def exist(self):
  115.         url               = '/api/v1/assets/admin-user/'
  116.         params            = {'username': self.name}
  117.         res               = HTTP.get(url, params=params)
  118.         res_data          = res.json()
  119.         if res.status_code in [200, 201] and res_data:
  120.             self.id       = res_data[0].get('id')
  121.         else:
  122.             self.create()
  124.     def create(self):
  125.         print("创建管理用户 {}".format(self.name))
  126.         url               = '/api/v1/assets/admin-users/'
  127.         data              = {
  128.             'name': self.name,
  129.             'username': self.username,
  130.             'password': self.password
  131.         }
  132.         res               = HTTP.post(url, json=data)
  133.         self.id           = res.json().get('id')
  135.     def perform(self):
  136.         self.exist()
  138. class Asset(object):
  140.     def __init__(self):
  141.         self.id           = None
  142.         self.name         = asset_name
  143.         self.ip           = asset_ip
  144.         self.platform     = asset_platform
  145.         self.protocols    = asset_protocols
  146.         self.admin_user   = AdminUser()
  147.         self.node         = Node()
  149.     def exist(self):
  150.         url               = '/api/v1/assets/assets/'
  151.         params            = {
  152.             'hostname': self.name
  153.         }
  154.         res               = HTTP.get(url, params)
  155.         res_data          = res.json()
  156.         if res.status_code in [200, 201] and res_data:
  157.             self.id       = res_data[0].get('id')
  158.         else:
  159.             self.create()
  161.     def create(self):
  162.         print("创建资产 {}".format(self.ip))
  163.         self.admin_user.perform()
  164.         self.node.perform()
  165.         url               = '/api/v1/assets/assets/'
  166.         data              = {
  167.             'hostname': self.ip,
  168.             'ip': self.ip,
  169.             'platform': self.platform,
  170.             'protocols': self.protocols,
  171.             'admin_user': self.admin_user.id,
  172.             'nodes': [self.node.id],
  173.             'is_active': True
  174.         }
  175.         res               = HTTP.post(url, json=data)
  176.         self.id           = res.json().get('id')
  178.     def perform(self):
  179.         self.exist()
  181. class SystemUser(object):
  183.     def __init__(self):
  184.         self.id           = None
  185.         self.name         = assets_system_name
  186.         self.username     = assets_system_username
  188.     def exist(self):
  189.         url               = '/api/v1/assets/system-users/'
  190.         params            = {'name': self.name}
  191.         res               = HTTP.get(url, params)
  192.         res_data          = res.json()
  193.         if res.status_code in [200, 201] and res_data:
  194.             self.id       = res_data[0].get('id')
  195.         else:
  196.             self.create()
  198.     def create(self):
  199.         print("创建系统用户 {}".format(self.name))
  200.         url               = '/api/v1/assets/system-users/'
  201.         data              = {
  202.             'name': self.name,
  203.             'username': self.username,
  204.             'login_mode': 'auto',
  205.             'protocol': 'ssh',
  206.             'auto_push': True,
  207.             'sudo': 'All',
  208.             'shell': '/bin/bash',
  209.             'auto_generate_key': True,
  210.             'is_active': True
  211.         }
  212.         res               = HTTP.post(url, json=data)
  213.         self.id           = res.json().get('id')
  215.     def perform(self):
  216.         self.exist()
  218. class AssetPermission(object):
  220.     def __init__(self):
  221.         self.name         = perm_name
  222.         self.user         = User()
  223.         self.asset        = Asset()
  224.         self.system_user  = SystemUser()
  226.     def create(self):
  227.         print("创建资产授权名称 {}".format(self.name))
  228.         url               = '/api/v1/perms/asset-permissions/'
  229.         data              = {
  230.             'name': self.name,
  231.             'users': [self.user.id],
  232.             'assets': [self.asset.id],
  233.             'system_users': [self.system_user.id],
  234.             'actions': ['all'],
  235.             'is_active': True,
  236.             'date_start': perm_date_start,
  237.             'date_expired': perm_date_expired
  238.         }
  239.         res               = HTTP.post(url, json=data)
  240.         res_data          = res.json()
  241.         if res.status_code in [200, 201] and res_data:
  242.             print("创建资产授权规则成功: ", res_data)
  243.         else:
  244.             print("创建授权规则失败: ", res_data)
  246.     def perform(self):
  247.         self.user.perform()
  248.         self.asset.perform()
  249.         self.system_user.perform()
  250.         self.create()
  252. class APICreateAssetPermission(object):
  254.     def __init__(self):
  255.         self.jms_url      = jms_url
  256.         self.username     = jms_username
  257.         self.password     = jms_password
  258.         self.token        = None
  259.         self.server       = None
  261.     def init_http(self):
  262.         HTTP.server       = self.jms_url
  263.         HTTP.get_token(self.username, self.password)
  265.     def perform(self):
  266.         self.init_http()
  267.         self.perm         = AssetPermission()
  268.         self.perm.perform()
  271. if __name__ == '__main__':
  273.     # jumpserver url 地址
  274.     jms_url                = 'http://192.168.100.244'
  276.     # 管理员账户
  277.     jms_username           = 'admin'
  278.     jms_password           = 'admin'
  280.     # 资产节点
  281.     asset_node_name        = 'test'
  283.     # 资产信息
  284.     asset_name             = '192.168.100.1'
  285.     asset_ip               = '192.168.100.1'
  286.     asset_platform         = 'Linux'
  287.     asset_protocols        = ['ssh/22']
  289.     # 资产管理用户
  290.     assets_admin_name      = 'test_root'
  291.     assets_admin_username  = 'root'
  292.     assets_admin_password  = 'test123456'
  294.     # 资产系统用户
  295.     assets_system_name     = 'test'
  296.     assets_system_username = 'test'
  298.     # 用户用户名
  299.     user_name              = '测试用户'
  300.     user_username          = 'test'
  301.     user_email             = 'test@jumpserver.org'
  303.     # 资产授权
  304.     perm_name              = 'AutoPerm' +'_'+ (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
  305.     perm_date_start        = '2021-05-01 14:25:47 +0800'
  306.     perm_date_expired      = '2021-06-01 14:25:47 +0800'
  308.     api = APICreateAssetPermission()
  309.     api.perform()

Access Key

  1. #!/usr/bin/env python3
  2. # -*- coding:utf-8 -*-
  4. import sys, requests, time, datetime
  5. from httpsig.requests_auth import HTTPSignatureAuth
  7. class HTTP:
  8.     server = None
  9.     auth   = None
  11.     @classmethod
  12.     def get_auth(cls, accesskeyid, accesskeysecret):
  13.         signature_headers = ['(request-target)', 'accept', 'date']
  14.         auth              = HTTPSignatureAuth(key_id=accesskeyid, secret=accesskeysecret, algorithm='hmac-sha256', headers=signature_headers)
  15.         cls.auth          = auth
  17.     @classmethod
  18.     def get(cls, url, params=None, **kwargs):
  19.         url               = cls.server + url
  20.         GMT_FORMAT        = '%a, %d %b %Y %H:%M:%S GMT'
  21.         headers           = {
  22.             'Accept': 'application/json',
  23.             'Date': datetime.datetime.utcnow().strftime(GMT_FORMAT)
  24.         }
  25.         kwargs['auth']    = cls.auth
  26.         kwargs['headers'] = headers
  27.         res               = requests.get(url, params, **kwargs)
  28.         return res
  30.     @classmethod
  31.     def post(cls, url, data=None, json=None, **kwargs):
  32.         url               = cls.server + url
  33.         GMT_FORMAT        = '%a, %d %b %Y %H:%M:%S GMT'
  34.         headers           = {
  35.             'Accept': 'application/json',
  36.             'Date': datetime.datetime.utcnow().strftime(GMT_FORMAT)
  37.         }
  38.         kwargs['auth']    = cls.auth
  39.         kwargs['headers'] = headers
  40.         res               = requests.post(url, data, json, **kwargs)
  41.         return res
  43. class User(object):
  45.     def __init__(self):
  46.         self.id           = None
  47.         self.name         = user_name
  48.         self.username     = user_username
  49.         self.email        = user_email
  51.     def exist(self):
  52.         url               = '/api/v1/users/users/'
  53.         params            = {'username': self.username}
  54.         res               = HTTP.get(url, params=params)
  55.         res_data          = res.json()
  56.         if res.status_code in [200, 201] and res_data:
  57.             self.id       = res_data[0].get('id')
  58.         else:
  59.             self.create()
  61.     def create(self):
  62.         print("创建用户 {}".format(self.username))
  63.         url               = '/api/v1/users/users/'
  64.         data              = {
  65.             'name': self.name,
  66.             'username': self.username,
  67.             'email': self.email,
  68.             'is_active': True
  69.         }
  70.         res               = HTTP.post(url, json=data)
  71.         self.id           = res.json().get('id')
  73.     def perform(self):
  74.         self.exist()
  76. class Node(object):
  78.     def __init__(self):
  79.         self.id           = None
  80.         self.name         = asset_node_name
  82.     def exist(self):
  83.         url               = '/api/v1/assets/nodes/'
  84.         params            = {'value': self.name}
  85.         res               = HTTP.get(url, params=params)
  86.         res_data          = res.json()
  87.         if res.status_code in [200, 201] and res_data:
  88.             self.id       = res_data[0].get('id')
  89.         else:
  90.             self.create()
  92.     def create(self):
  93.         print("创建资产节点 {}".format(self.name))
  94.         url               = '/api/v1/assets/nodes/'
  95.         data              = {
  96.             'value': self.name
  97.         }
  98.         res               = HTTP.post(url, json=data)
  99.         self.id           = res.json().get('id')
  101.     def perform(self):
  102.         self.exist()
  104. class AdminUser(object):
  106.     def __init__(self):
  107.         self.id           = None
  108.         self.name         = assets_admin_name
  109.         self.username     = assets_admin_username
  110.         self.password     = assets_admin_password
  112.     def exist(self):
  113.         url               = '/api/v1/assets/admin-user/'
  114.         params            = {'username': self.name}
  115.         res               = HTTP.get(url, params=params)
  116.         res_data          = res.json()
  117.         if res.status_code in [200, 201] and res_data:
  118.             self.id       = res_data[0].get('id')
  119.         else:
  120.             self.create()
  122.     def create(self):
  123.         print("创建管理用户 {}".format(self.name))
  124.         url               = '/api/v1/assets/admin-users/'
  125.         data              = {
  126.             'name': self.name,
  127.             'username': self.username,
  128.             'password': self.password
  129.         }
  130.         res               = HTTP.post(url, json=data)
  131.         self.id           = res.json().get('id')
  133.     def perform(self):
  134.         self.exist()
  136. class Asset(object):
  138.     def __init__(self):
  139.         self.id           = None
  140.         self.name         = asset_name
  141.         self.ip           = asset_ip
  142.         self.platform     = asset_platform
  143.         self.protocols    = asset_protocols
  144.         self.admin_user   = AdminUser()
  145.         self.node         = Node()
  147.     def exist(self):
  148.         url               = '/api/v1/assets/assets/'
  149.         params            = {
  150.             'hostname': self.name
  151.         }
  152.         res               = HTTP.get(url, params)
  153.         res_data          = res.json()
  154.         if res.status_code in [200, 201] and res_data:
  155.             self.id       = res_data[0].get('id')
  156.         else:
  157.             self.create()
  159.     def create(self):
  160.         print("创建资产 {}".format(self.ip))
  161.         self.admin_user.perform()
  162.         self.node.perform()
  163.         url               = '/api/v1/assets/assets/'
  164.         data              = {
  165.             'hostname': self.ip,
  166.             'ip': self.ip,
  167.             'platform': self.platform,
  168.             'protocols': self.protocols,
  169.             'admin_user': self.admin_user.id,
  170.             'nodes': [self.node.id],
  171.             'is_active': True
  172.         }
  173.         res               = HTTP.post(url, json=data)
  174.         self.id           = res.json().get('id')
  176.     def perform(self):
  177.         self.exist()
  179. class SystemUser(object):
  181.     def __init__(self):
  182.         self.id           = None
  183.         self.name         = assets_system_name
  184.         self.username     = assets_system_username
  186.     def exist(self):
  187.         url               = '/api/v1/assets/system-users/'
  188.         params            = {'name': self.name}
  189.         res               = HTTP.get(url, params)
  190.         res_data          = res.json()
  191.         if res.status_code in [200, 201] and res_data:
  192.             self.id       = res_data[0].get('id')
  193.         else:
  194.             self.create()
  196.     def create(self):
  197.         print("创建系统用户 {}".format(self.name))
  198.         url               = '/api/v1/assets/system-users/'
  199.         data              = {
  200.             'name': self.name,
  201.             'username': self.username,
  202.             'login_mode': 'auto',
  203.             'protocol': 'ssh',
  204.             'auto_push': True,
  205.             'sudo': 'All',
  206.             'shell': '/bin/bash',
  207.             'auto_generate_key': True,
  208.             'is_active': True
  209.         }
  210.         res               = HTTP.post(url, json=data)
  211.         self.id           = res.json().get('id')
  213.     def perform(self):
  214.         self.exist()
  216. class AssetPermission(object):
  218.     def __init__(self):
  219.         self.name         = perm_name
  220.         self.user         = User()
  221.         self.asset        = Asset()
  222.         self.system_user  = SystemUser()
  224.     def create(self):
  225.         print("创建资产授权名称 {}".format(self.name))
  226.         url               = '/api/v1/perms/asset-permissions/'
  227.         data              = {
  228.             'name': self.name,
  229.             'users': [self.user.id],
  230.             'assets': [self.asset.id],
  231.             'system_users': [self.system_user.id],
  232.             'actions': ['all'],
  233.             'is_active': True,
  234.             'date_start': perm_date_start,
  235.             'date_expired': perm_date_expired
  236.         }
  237.         res               = HTTP.post(url, json=data)
  238.         res_data          = res.json()
  239.         if res.status_code in [200, 201] and res_data:
  240.             print("创建资产授权规则成功: ", res_data)
  241.         else:
  242.             print("创建授权规则失败: ", res_data)
  244.     def perform(self):
  245.         self.user.perform()
  246.         self.asset.perform()
  247.         self.system_user.perform()
  248.         self.create()
  250. class APICreateAssetPermission(object):
  252.     def __init__(self):
  253.         self.jms_url         = jms_url
  254.         self.accesskeyid     = jms_accesskeyid
  255.         self.accesskeysecret = jms_accesskeysecret
  256.         self.auth            = None
  257.         self.server          = None
  259.     def init_http(self):
  260.         HTTP.server          = self.jms_url
  261.         HTTP.get_auth(self.accesskeyid, self.accesskeysecret)
  263.     def perform(self):
  264.         self.init_http()
  265.         self.perm            = AssetPermission()
  266.         self.perm.perform()
  269. if __name__ == '__main__':
  271.     # jumpserver url 地址
  272.     jms_url                = 'http://192.168.100.244'
  274.     # 管理员 AK SK
  275.     jms_accesskeyid        = ''
  276.     jms_accesskeysecret    = ''
  278.     # 资产节点
  279.     asset_node_name        = 'test'
  281.     # 资产信息
  282.     asset_name             = '192.168.100.1'
  283.     asset_ip               = '192.168.100.1'
  284.     asset_platform         = 'Linux'
  285.     asset_protocols        = ['ssh/22']
  287.     # 资产管理用户
  288.     assets_admin_name      = 'test_root'
  289.     assets_admin_username  = 'root'
  290.     assets_admin_password  = 'test123456'
  292.     # 资产系统用户
  293.     assets_system_name     = 'test'
  294.     assets_system_username = 'test'
  296.     # 用户用户名
  297.     user_name              = '测试用户'
  298.     user_username          = 'test'
  299.     user_email             = 'test@jumpserver.org'
  301.     # 资产授权
  302.     perm_name              = 'AutoPerm' +'_'+ (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
  303.     perm_date_start        = '2021-05-01 14:25:47 +0800'
  304.     perm_date_expired      = '2021-06-01 14:25:47 +0800'
  306.     api = APICreateAssetPermission()
  307.     api.perform()