系统运维工程师的法宝：python paramiko

paramiko是用python语言写的一个模块，遵循SSH2协议，支持以加密和认证的方式，进行远程服务器的连接。

使用paramiko可以很好的解决以下问题：

需要使用windows客户端，

远程连接到Linux服务器，查看上面的日志状态，批量配置远程服务器，文件上传，文件下载等

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import pexpect

def ssh_cmd(ip, passwd, cmd):

ret = -1

ssh = pexpect.spawn ('ssh root@%s "%s"' % (ip, cmd))

try:

i = ssh.expect (['password:', 'continue connecting (yes/no)?'], timeout=5)

if i == 0 :

ssh.sendline (passwd)

elif i == 1:

ssh.sendline('yes\n')

ssh.expect('password: ')

ssh.sendline(passwd)

ssh.sendline(cmd)

r = ssh.read()

print r

ret = 0

except pexpect.EOF:

print "EOF"

ssh.close()

ret = -1

except pexpect.TIMEOUT:

print "TIMEOUT"

ssh.close()

ret = -2

return ret

#-*- coding: utf-8 -*-

#!/usr/bin/python

import paramiko

import threading

def ssh2(ip,username,passwd,cmd):

try:

ssh = paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh.connect (ip,22,username,passwd,timeout=5)

for m in cmd:

stdin, stdout, stderr = ssh.exec_command (m)

# stdin.write("Y") #简单交互，输入 ‘Y’

out = stdout.readlines()

#屏幕输出

for o in out:

print o,

print '%s\tOK\n'%(ip)

ssh.close()

except :

print '%s\tError\n'%(ip)

if __name__=='__main__':

cmd = ['cal','echo hello!']#你要执行的命令列表

username = "" #用户名

passwd = "" #密码

threads = [] #多线程

print "Begin......"

for i in range(1,254):

ip = '192.168.1.'+str(i)

a= threading.Thread (target=ssh2,args=(ip,username,passwd,cmd))

a.start()

"paramiko" is a combination of the esperanto words for "paranoid" and

"friend". it's a module for python 2.5+ that implements the SSH2 protocol

for secure (encrypted and authenticated) connections to remote machines.

unlike SSL (aka TLS), SSH2 protocol does not require hierarchical

certificates signed by a powerful central authority. you may know SSH2 as

the protocol that replaced telnet and rsh for secure access to remote

shells, but the protocol also includes the ability to open arbitrary

channels to remote services across the encrypted tunnel (this is how sftp

works, for example).

it is written entirely in python (no C or platform-dependent code) and is

released under the GNU LGPL (lesser GPL).

the package and its API is fairly well documented in the "doc/" folder

that should have come with this archive.

Requirements

------------

- python 2.5 or better

- pycrypto 2.1 or better

If you have setuptools, you can build and install paramiko and all its

dependencies with this command (as root)::

easy_install ./

Portability

-----------

i code and test this library on Linux and MacOS X. for that reason, i'm

pretty sure that it works for all posix platforms, including MacOS. it

should also work on Windows, though i don't test it as frequently there.

if you run into Windows problems, send me a patch: portability is important

to me.

some python distributions don't include the utf-8 string encodings, for

reasons of space (misdirected as that is). if your distribution is

missing encodings, you'll see an error like this::

LookupError: no codec search functions registered: can't find encoding

this means you need to copy string encodings over from a working system.

(it probably only happens on embedded systems, not normal python

installs.) Valeriy Pogrebitskiy says the best place to look is

``.../lib/python*/encodings/__init__.py``.

Bugs & Support

--------------

Please file bug reports at https://github.com/paramiko/paramiko/. There is currently no mailing list but we plan to create a new one ASAP.

Demo

----

several demo scripts come with paramiko to demonstrate how to use it.

probably the simplest demo of all is this::

import paramiko, base64

key = paramiko.RSAKey(data=base64.decodestring('AAA...'))

client = paramiko.SSHClient()

client.get_host_keys().add('ssh.example.com', 'ssh-rsa', key)

client.connect('ssh.example.com', username='strongbad', password='thecheat')

stdin, stdout, stderr = client.exec_command('ls')

for line in stdout:

print '... ' + line.strip('\n')

client.close()

...which prints out the results of executing ``ls`` on a remote server.

(the host key 'AAA...' should of course be replaced by the actual base64

encoding of the host key. if you skip host key verification, the

connection is not secure!)

the following example scripts (in demos/) get progressively more detailed:

:demo_simple.py:

calls invoke_shell() and emulates a terminal/tty through which you can

execute commands interactively on a remote server. think of it as a

poor man's ssh command-line client.

:demo.py:

same as demo_simple.py, but allows you to authenticiate using a

private key, attempts to use an SSH-agent if present, and uses the long

form of some of the API calls.

:forward.py:

command-line script to set up port-forwarding across an ssh transport.

(requires python 2.3.)

:demo_sftp.py:

opens an sftp session and does a few simple file operations.

:demo_server.py:

an ssh server that listens on port 2200 and accepts a login for

'robey' (password 'foo'), and pretends to be a BBS. meant to be a

very simple demo of writing an ssh server.

:demo_keygen.py:

an key generator similar to openssh ssh-keygen(1) program with

paramiko keys generation and progress functions.

Use

---

the demo scripts are probably the best example of how to use this package.

there is also a lot of documentation, generated with epydoc, in the doc/

folder. point your browser there. seriously, do it. mad props to

epydoc, which actually motivated me to write more documentation than i

ever would have before.

there are also unit tests here::

$ python ./test.py

which will verify that most of the core components are working correctly.

－、执行远程命令:

#!/usr/bin/python

#coding:utf-8

import paramiko

port =22

ssh = paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh.connect("*.*.*.*",port,"username", "password")

stdin, stdout, stderr = ssh.exec_command("你的命令")

print stdout.readlines()

ssh.close()

二、上传文件到远程

#!/usr/bin/python

#coding:utf-8

import paramiko

port =22

t = paramiko.Transport(("IP",port))

t.connect(username = "username", password = "password")

sftp = paramiko.SFTPClient.from_transport(t)

remotepath='/tmp/test.txt'

localpath='/tmp/test.txt'

sftp.put(localpath,remotepath)

t.close()

三、从远程下载文件

#!/usr/bin/python

#coding:utf-8

import paramiko

port =22

t = paramiko.Transport(("IP",port))

t.connect(username = "username", password = "password")

sftp = paramiko.SFTPClient.from_transport(t)

remotepath='/tmp/test.txt'

localpath='/tmp/test.txt'

sftp.get(remotepath, localpath)

t.close()

四、执行多个命令

#!/usr/bin/python

#coding:utf-8

import sys

sys.stderr = open('/dev/null') # Silence silly warnings from paramiko

import paramiko as pm

sys.stderr = sys.__stderr__

import os

class AllowAllKeys(pm.MissingHostKeyPolicy):

def missing_host_key(self, client, hostname, key):

return

HOST = '127.0.0.1'

USER = ''

PASSWORD = ''

client = pm.SSHClient()

client.load_system_host_keys()

client.load_host_keys(os.path.expanduser('~/.ssh/known_hosts'))

client.set_missing_host_key_policy(AllowAllKeys())

client.connect(HOST, username=USER, password=PASSWORD)

channel = client.invoke_shell()

stdin = channel.makefile('wb')

stdout = channel.makefile('rb')

stdin.write('''

cd tmp

ls

exit

''')

print stdout.read()

stdout.close()

stdin.close()

client.close()

五、获取多个文件

#!/usr/bin/python

#coding:utf-8

import paramiko

import os

ssh = paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh.connect('localhost',username='****')

apath = '/var/log'

apattern = '"*.log"'

rawcommand = 'find {path} -name {pattern}'

command = rawcommand.format(path=apath, pattern=apattern)

stdin, stdout, stderr = ssh.exec_command(command)

filelist = stdout.read().splitlines()

ftp = ssh.open_sftp()

for afile in filelist:

(head, filename) = os.path.split(afile)

print(filename)

ftp.get(afile, './'+filename)

ftp.close()

ssh.close()

paramiko是用python语言写的一个模块，遵循SSH2协议，支持以加密和认证的方式，进行远程服务器的连接。paramiko支持Linux, Solaris, BSD, MacOS X, Windows等平台通过SSH从一个平台连接到另外一个平台。

利用该模块，可以方便的进行ssh连接和sftp协议进行sftp文件传输。

paramiko是一个基于SSH用于连接远程服务器并执行相关操作（SSHClient和SFTPClinet,即一个是远程连接，一个是上传下载服务），使用该模块可以对远程服务器进行命令或文件操作，值得一说的是，

fabric和ansible内部的远程管理就是使用的paramiko来实现。

pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto

pip3 install pycrypto

pip3 install paramiko

一、paramiko模块的安装

paramiko模块依赖PyCrypto模块，而PyCrypto需要GCC库编译，不过一般发行版的源里带有该模块。这里以centos6为例，直接借助以下命令可以直接完成安装：

yum install gcc python-crypto python-paramiko python-devel -y

windows版下可以安装windows版的GCC(MinGW)，然后编辑安装pycrypto和paramiko ，下载安成后，直接运行python.exe setup.py build 和 python.exe setup.py install 就可以了。

二、paramiko的连接

使用paramiko模块有两种连接方式，一种是通过paramiko.SSHClient()函数，另外一种是通过paramiko.Transport()函数。

（1）基于用户名和密码的连接

import paramiko

# 创建SSH对象

ssh = paramiko.SSHClient()

# 允许连接不在know_hosts文件中的主机

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 连接服务器

ssh.connect(hostname='c1.salt.com', port=22, username='GSuser', password='123')

# 执行命令

stdin, stdout, stderr = ssh.exec_command('ls')

# 获取命令结果

result = stdout.read()

# 关闭连接

ssh.close()

SSHClient 封装 Transport

import paramiko

transport =paramiko.Transport(('hostname', 22))

transport.connect(username='GSuser', password='123')

ssh = paramiko.SSHClient()

ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command('df')

print(stdout.read())

transport.close()

(2）基于公钥秘钥连接

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')

# 创建SSH对象

ssh = paramiko.SSHClient()

# 允许连接不在know_hosts文件中的主机

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# 连接服务器

ssh.connect(hostname='c1.salt.com', port=22, username='wupeiqi', key=private_key)

# 执行命令

stdin, stdout, stderr = ssh.exec_command('df')

# 获取命令结果

result = stdout.read()

# 关闭连接

ssh.close()

SSHClient 封装Transport

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')

transport = paramiko.Transport(('hostname', 22))

transport.connect(username='wupeiqi', pkey=private_key)

ssh = paramiko.SSHClient()

ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command('df')

transport.close()

SFTPClient:

用于连接远程服务器并进行上传下载功能。

（1）基于用户名密码上传下载

import paramiko

transport = paramiko.Transport(('hostname',22))

transport.connect(username='GSuser',password='123')

sftp = paramiko.SFTPClient.from_transport(transport)

# 将location.py 上传至服务器 /tmp/test.py

sftp.put('/tmp/location.py', '/tmp/test.py')

# 将remove_path 下载到本地 local_path

sftp.get('remove_path', 'local_path')

transport.close()

（2）基于公钥秘钥上传下载

import paramiko

private_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')

transport = paramiko.Transport(('hostname', 22))

transport.connect(username='GSuser', pkey=private_key )

sftp = paramiko.SFTPClient.from_transport(transport)

# 将location.py 上传至服务器 /tmp/test.py

sftp.put('/tmp/location.py', '/tmp/test.py')

# 将remove_path 下载到本地 local_path

sftp.get('remove_path', 'local_path')

transport.close()

下面是两种使用paramiko连接到linux服务器的代码

方式一：

ssh = paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh.connect("某IP地址",22,"用户名", "口令")

上面的第二行代码的作用是允许连接不在know_hosts文件中的主机。

方式二：

t = paramiko.Transport((“主机”,”端口”))

t.connect(username = “用户名”, password = “口令”)

如果连接远程主机需要提供密钥，上面第二行代码可改成：

t.connect(username = “用户名”, password = “口令”, hostkey=”密钥”)

从widnows端下载linux服务器上的文件

#!/usr/bin/python

import paramiko

t = paramiko.Transport((“主机”,”端口”))

t.connect(username = “用户名”, password = “口令”)

sftp = paramiko.SFTPClient.from_transport(t)

remotepath=’/var/log/system.log’

localpath=’/tmp/system.log’

sftp.get(remotepath, localpath)

t.close()

从widnows端上传文件到linux服务器

#!/usr/bin/python

import paramiko

t = paramiko.Transport((“主机”,”端口”))

t.connect(username = “用户名”, password = “口令”)

sftp = paramiko.SFTPClient.from_transport(t)

remotepath=’/var/log/system.log’

localpath=’/tmp/system.log’

sftp.put(localpath,remotepath)

t.close()

windows对linux运行任意命令,并将结果输出

如果linux服务器开放了22端口，在windows端，我们可以使用paramiko远程连接到该服务器，并执行任意命令，然后通过 print或其它方式得到该结果，

#!/usr/bin/python

import paramiko

ssh = paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh.connect("某IP地址",22,"用户名", "口令")

stdin, stdout, stderr = ssh.exec_command("你的命令")

print stdout.readlines()

ssh.close()

单个文件小传下载的示例：

import paramiko

#建立一个加密的管道

scp=paramiko.Transport(('192.168.0.102',22))

#建立连接

scp.connect(username='root',password='361way')

#建立一个sftp客户端对象，通过ssh transport操作远程文件

sftp=paramiko.SFTPClient.from_transport(scp)

#Copy a remote file (remotepath) from the SFTP server to the local host

sftp.get('/root/testfile','/tmp/361way')

#Copy a local file (localpath) to the SFTP server as remotepath

sftp.put('/root/crash-6.1.6.tar.gz','/tmp/crash-6.1.6.tar.gz')

scp.close()

一个目录下多个文件上传下载的示例：

#!/usr/bin/env python

#-*- coding: utf-8 -*-

import paramiko,datetime,os

hostname='192.168.0.102'

username='root'

password='361way'

port=22

local_dir='/tmp/getfile'

remote_dir='/tmp/abc'

try:

t=paramiko.Transport((hostname,port))

t.connect(username=username,password=password)

sftp=paramiko.SFTPClient.from_transport(t)

#files=sftp.listdir(dir_path)

files=sftp.listdir(remote_dir)

for f in files:

print ''

print '#########################################'

print 'Beginning to download file from %s %s ' % (hostname,datetime.datetime.now())

print 'Downloading file:',os.path.join(remote_dir,f)

sftp.get(os.path.join(remote_dir,f),os.path.join(local_dir,f))#下载

#sftp.put(os.path.join(local_dir,f),os.path.join(remote_dir,f))#上传

print 'Download file success %s ' % datetime.datetime.now()

print ''

print '##########################################'

t.close()

except Exception:

print "connect error!"

利用paramiko实现ssh的交互式连接

以下是通过paramiko模块直接用ssh协议登陆到远程服务器的操作代码，这里先定义一个interactive模块，代码如下：

import socket

import sys

# windows does not have termios...

try:

import termios

import tty

has_termios = True

except ImportError:

has_termios = False

def interactive_shell(chan):

if has_termios:

posix_shell(chan)

else:

windows_shell(chan)

def posix_shell(chan):

import select

oldtty = termios.tcgetattr(sys.stdin)

try:

tty.setraw(sys.stdin.fileno())

tty.setcbreak(sys.stdin.fileno())

chan.settimeout(0.0)

while True:

r, w, e = select.select([chan, sys.stdin], [], [])

if chan in r:

try:

x = chan.recv(1024)

if len(x) == 0:

print 'rn*** EOFrn',

break

sys.stdout.write(x)

sys.stdout.flush()

except socket.timeout:

pass

if sys.stdin in r:

x = sys.stdin.read(1)

if len(x) == 0:

break

chan.send(x)

finally:

termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)

# thanks to Mike Looijmans for this code

def windows_shell(chan):

import threading

sys.stdout.write("Line-buffered terminal emulation. Press F6 or ^Z to send EOF.rnrn")

def writeall(sock):

while True:

data = sock.recv(256)

if not data:

sys.stdout.write('rn*** EOF ***rnrn')

sys.stdout.flush()

break

sys.stdout.write(data)

sys.stdout.flush()

writer = threading.Thread(target=writeall, args=(chan,))

writer.start()

try:

while True:

d = sys.stdin.read(1)

if not d:

break

chan.send(d)

except EOFError:

# user hit ^Z or F6

pass

import paramiko

import interactive

#记录日志

paramiko.util.log_to_file('/tmp/test')

#建立ssh连接

ssh=paramiko.SSHClient()

ssh.load_system_host_keys()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

ssh.connect('192.168.0.102',port=22,username='root',password='xxxxxx',compress=True)

#建立交互式shell连接

channel=ssh.invoke_shell()

#建立交互式管道

interactive.interactive_shell(channel)

#关闭连接

channel.close()

ssh.close()

实现远程命令执行和文件上传

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import paramiko

class SSHConnection(object):

def __init__(self, host='192.168.12.68', port=22, username='locojoy',pwd='123321QQ!'):

self.host = host

self.port = port

self.username = username

self.pwd = pwd

self.__k = None

def run(self):

self.connect() # 连接远程服务器

self.upload('db.py','/tmp/1.py') # 将本地的db.py文件上传到远端服务器的/tmp/目录下并改名为1.py

self.cmd('df') # 执行df 命令

self.close() # 关闭连接

def connect(self):

transport = paramiko.Transport((self.host, self.port))

transport.connect(username=self.username, password=self.pwd)

self.__transport = transport

def close(self):

self.__transport.close()

def upload(self,local_path,target_path):

sftp = paramiko.SFTPClient.from_transport(self.__transport)

sftp.put(local_path,target_path)

def cmd(self, command):

ssh = paramiko.SSHClient()

ssh._transport = self.__transport

# 执行命令

stdin, stdout, stderr = ssh.exec_command(command)

# 获取命令结果

result = stdout.read()

print(result)

return result

obj = SSHConnection()

obj.run()

paramiko在堡垒机中的应用

简单实例：远程连接一台主机，操作命令，linux版本，输入终端为回车则发送命令。不支持tab补全功能

import paramiko, sys, os, socket, select, getpass

from paramiko.py3compat import u # 在python3中是这样使用的，如果在Python2中则注释这行

# 这个程序依赖于终端，只能在Liunx下运行，windows用其他的方式

tran = paramiko.Transport(('192.168.12.68', 22,))

tran.start_client()

tran.auth_password('locojoy', '123321QQ!')

# 打开一个通道

chan = tran.open_session()

# 获取一个终端

chan.get_pty()

# 激活器

chan.invoke_shell()

# 原始的方法利用终端进行收发消息

# 利用sys.stdin,肆意妄为执行操作

# 用户在终端输入内容，并将内容发送至远程服务器

# 远程服务器执行命令，并将结果返回

# 用户终端显示内容

while True:

# 监视用户输入和服务器返回数据

# sys.stdin 处理用户输入

# chan 是之前创建的通道，用于接收服务器返回信息

# 通过select监听终端（输入输出),一旦变化，就将拿到的数据发送给服务器

# 通过监听socket句柄，如果有变化表示服务器要给我发消息

readable, writeable, error = select.select([chan, sys.stdin, ],[],[],1)

# 通过select.select 监听chan（打开的通道（和远程服务器连接的状态））, sys.stdin（输入），一旦变化就写入readable

# 当chan变化时，加入到readable，远程服务器发送内容过来

if chan in readable:

try:

x = u(chan.recv(1024)) # Python3用这个

# x = chan.recv(1024) Python2使用这个

if len(x) == 0:

print('\r\n*** EOF\r\n')

break

sys.stdout.write(x)# 写入缓冲区

sys.stdout.flush() # 刷新，将缓冲区内容显示出来

except socket.timeout:

pass

# 当sys.stdin 放入readable中时，将获取到的内容发送到远程服务器

if sys.stdin in readable:

inp = sys.stdin.readline()

chan.sendall(inp)

chan.close()

tran.close()

（2）每按一个键就发送记录，并支持tab自动补全

import paramiko, sys, os, socket, select, getpass, termios, tty

from paramiko.py3compat import u

tran = paramiko.Transport(('10.211.55.4', 22,))

tran.start_client()

tran.auth_password('wupeiqi', '123')

# 打开一个通道

chan = tran.open_session()

# 获取一个终端

chan.get_pty()

# 激活器

chan.invoke_shell()

# 获取原tty属性

oldtty = termios.tcgetattr(sys.stdin)

try:

# 为tty设置新属性

# 默认当前tty设备属性：

# 输入一行回车，执行

# CTRL+C 进程退出，遇到特殊字符，特殊处理。

# 这是为原始模式，不认识所有特殊符号

# 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器

tty.setraw(sys.stdin.fileno()) # 恢复终端原始状态，每按一个键就发送

chan.settimeout(0.0)

while True:

# 监视用户输入和远程服务器返回数据（socket）

# 阻塞，直到句柄可读

r, w, e = select.select([chan, sys.stdin], [], [], 1)

if chan in r: # 获取服务返回的内容

try:

x = u(chan.recv(1024))

if len(x) == 0:

print('\r\n*** EOF\r\n')

break

sys.stdout.write(x)

sys.stdout.flush()

except socket.timeout:

pass

if sys.stdin in r: # 发送命令

x = sys.stdin.read(1) # 读取一个字符

if len(x) == 0:

break

chan.send(x) # 发送一个字符

finally:

# 重新设置终端属性,将终端状态还原

termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)

chan.close()

tran.close()

系统运维工程师的法宝：python paramiko相关推荐

公开课：如何成为一名高级系统运维工程师（架构师）？
如何成为一名高级系统运维工程师(架构师)? --老男孩教育赵班长内容简介: 突破瓶颈,从普通系统运维成长为高级系统工程师.架构师,如何提升,需要掌握哪些技能和知识,公开课上为您解惑. 分享形 ...
Linux系统运维工程师PDF文档精选
收藏先,O(∩_∩)O~ Linux系统运维工程师PDF文档精选 1.高级Bash脚本编程指南 http://www.unixhot.com/pdf/bash.pdf 2.Linux 策略路由和流量 ...
运维工程师项目案例_【IT专场】系统运维工程师等岗位在线邀你入职，base上海|深圳|昆山...
今天的IT招聘专场推送的岗位有系统运维工程师Mainframe Cobol Programmer网络工程师base上海|深圳|昆山含"金"量满满供君挑选感兴趣的快投简历吧~ 系统运 ...
职业生涯规划（系统运维工程师）
自2010年6月至今, 在一家私企担任系统运维工程师一职位已2年,工作蛮轻松,但薪水不高. 最近内心深处总有些迷茫的感觉. 今年已经25岁,五年之内,如何才能有更好的发展,如何赚大钱?今后的发展方向在 ...
Linux系统运维工程师学习（基础一）
Linux系统运维工程师学习(基础一) 1.1计算机软硬件与操作系统介绍计算机系统的组成硬件系统主机(中央处理器,内部处理器) 外部设备(I/O设备接口,外部存储器,输入输出设备) 软件系统 ...
浅谈Linux系统运维工程师必备技能
一.什么是运维工程师相信读者们必定听说过linux,也听说过运维工程师.那么运维工程师是个什么概念呢? 百度百科上的官方解释如下: 运维工程师(Operations)在国内又称为运维开发工程师(De ...
系统运维工程师装逼完全指南
.全球化的认证有助于提升逼格,什么OCM.CCIE.RHCA.CISSP等等能考都考,再不济,也要有一张系统架构设计师或者网络规划设计师的信产部认证.每过一个认证,逼格提升一档. 2.TCP/IP协议 ...
python开发运维工程师_2020年Python运维工程师招聘招聘-Python运维工程师招聘招聘求职信息-拉勾招聘...
有关 AfterShip 2012 年成立于香港,公司自 2014 年起已实现持续盈利,且每年 100% 增长,公司目前暂时不需要融资.业务遍布全球,与全球 700 多家物流公司达成合作,涉及 30 ...
系统运维工程师面试题及参考答案
1. raid0 raid1 raid5 原理与区别 raid0至少2块硬盘.吞吐量大性能好同时读写,但损坏一个就完蛋 raid1至少2块硬盘.相当于一个镜像,一个存储.安全性比较高.但是性能比 ...
python运维工程师前景及待遇_做运维工程师有前途吗？
运维是一个进入门槛低,但是发展前景大的行业. 去年我们老板从运维总监职位退下来的时候年薪75万,所以不要小看这个行业. 但是前路漫漫,想在这个领域有长足的发展,要学习很多,付出很多. "今年 ...

系统运维工程师的法宝：python paramiko

系统运维工程师的法宝：python paramiko相关推荐

最新文章

热门文章