一般企业里的服务器采用的是什么系统?windows?还是linux?

首先说windows和Linux系统在企业的服务器中都是有使用的,关于一个企业是选择windows作为服务器系统还是Linux作为服务器系统还是要看企业对于服务器的需求和一些技术上的需要。

1、简要说一下windows系统和Linux系统。windows系统相信大家都不陌生,现在大家基本上使用的都是以windows操作系统为主,而服务器上使用的windows操作系统一般指的的是windows的服务器版本系统:windows server 系列。windows server系列也有很多的版本,如windows server2003、windows server 2008等。这些服务器版本的windows和普通windows版本的不同在于其是根据服务器需求进行开发的,如支持更大的内存、支持一些服务器的策略设置、支持服务器集群等,这些功能都是针对服务器的功能,总之windows server版本就是一个适合服务器的操作系统版本,其功能大多都是针对服务器的。再说一下Linux系统,Linux是一套免费使用和自由传播的类Unix操作系统,是一个基于POSIX和UNIX的多用户、多任务、支持多线程和多CPU的操作系统。它能运行主要的UNIX工具软件、应用程序和网络协议。它支持32位和64位硬件。Linux继承了Unix以网络为核心的设计思想,是一个性能稳定的多用户网络操作系统。以上是专业的解释,简单说Linux是一个免费的操作系统,其也是非常的好的支持服务器环境,且其不太适合图形化操作更适合命令行操作,而windows server是收费的系统,且其主要的还是图形化操作方式。

2、公司选择什么系统之性能和易用性。因为Linux是开源的操作系统,其功能可以自己定义和修改,且其没有图形化界面,总而言之Linux的一些特性使得Linux的效率要比windows高且其使用起来更加灵活,因为Linux的严格的用户权限管理机制使得Linux更加安全。虽然windows的图形界面会在一定的程度上降低windows的性能,但是图形化的界面也为windows带来了操作简单方便的特点,且大家都是使用windows出身,那么 windows server系统的操作学起来要比Linux简单的多。总结:个人认为Linux比windows server的性能更好,而windows server比Linux有更好的易用性。

3、公司选择什么系统之用途和技术搭配和成本。关于服务器的用途决定了其安装什么操作系统,比如公司需要搭建一台服务器进行系统网络和局域网的域管理,那么此时应该使用的当然是windows server操作系统。在比如公司的需要对外发布一个web网站,公司决定使用asp.net作为网站后台,我们都知道asp.net的*好组合是windows server + IIS +sqlserver数据库,那么此时公司的机房服务器也可能要安装windows server 系统,而我们要发布一个php的网站,那么我们也都知道php的*佳运行环境是lamp即Linux+Apache+mysql数据库+php,此时可能我们需要的采用Linux作为操作系统。

再说一下成本,Linux的是开元不收费的系统,而windows server是收费的操作系统,但是公司请一个Linux的运维管理员的成本要高于windows server的管理员,这些问题都是公司需要考虑平衡的,毕竟公司要考虑公司的利益。

*后,以上就是个人对于公司选择什么操作系统作为服务器操作系统的一些看法,也可能有很多其他的因素影响着这个选择,以上只是个人的一些看法和其中的一些因素。

服务器操作系统有哪些?

办公电脑想必都在用XP、Win7、Win10等操作系统,那么搭建网站所使用服务器需要使用什么操作系统。服务器操作系统主要分为四大流派:WINDOWS、LINUX、NETWARE、UNIX。

服务器操作系统
1、WINDOWS 服务器操作系统
常用版本WINNT 4.0 Server、Win2000/AdvancedServer、Win2003/AdvancedServer,WINDOWS SERVER 2008,,Windows服务器操作系统派应用,结合.Net开发环境,为微软企业用户提供了良好的应用框架。
2、Linux 服务器操作系统
LINUX操作系统虽然与UNIX操作系统类似,但是它不是UNIX操作系统的变种。Torvald从开始编写内核代码时仿效UNIX,几乎所有UNIX的工具与外壳都可以运行在LINUX上。
由于Linux内核具有稳定性、开放源代码等特点,另外,使用者不必支付打包的使用费用,所以Linux获得了IBM、戴尔等世界厂商的支持,同时景安DEll服务器也支持Linux操作系统。
3、NetWare 服务器操作系统
在一些特定行业和事业单位中,NetWare的批处理功能和安全、稳定的系统性能也有很大的生存空间。NetWare目前常用的版本主要有Novell的3.11、3.12、4.10、5.0等中英文版。
4、Unix 服务器操作系统
Unix服务器操作系统由AT&T公司和SCO公司共同推出,主要支持大型的文件系统服务、数据服务等应用。目前市面上流传的主要有SCOSVR、BSDUnix、SUNSolaris、IBM-AIX、HP-UX 。

AWS EC2主机类型的区别和联系

AWS EC2 Instance Type 有很多种类型,什么t2.small, m4.xlarge, c3.2xlarge等,那么这些t啊,m啊到底是什么意思呢?我们接下来一一介绍。

按照用途分为五大类:

1 通用型,提供平衡的计算,内存,和网络能力,t2,m5系列。

2 计算优化型,c5,c4,c3系列。

3 内存优化型,x1,r4系列。

4 加速计算型,p3,p2,g3,f1系列

5 存储优化型,h1,i3,d2系列。

有了这些大方向后,你就可以去选择相应的类型了。如果实在不知道买什么类型合适,就买通用型的,因为各个方面都很平衡。

1 通用型实例有t2,m5,m4,m3等系列。

t2实例集合是CPU突发性能实例,有基本的计算能力,空闲时累计CPU积分,突发时可以短期发挥高性能,适合于web server,数据库等。具体实例类型有:t2.nano, t2.micro, t2.small, t2.medium, t2.large, t2.xlarge, t2.2xlarge
%title插图%num

可以看出从nano到2xlarge,虚拟CPU的数量在增加,累计能力也在增加,内存也在增加,所以其整体性能越来越好,当然买个也越来越贵。

m5实例集是新一代的通用型实例集。 整体来讲比t2系列要性能好。可以看出内存能达到384GB,96核CPU。m4系列要比m5系列便宜一些,同理m3比m4系列要便宜一些。
%title插图%num

2 计算优化型有c5,c4,c3,从名字上可以看出性能上c5>c4>c3,如果你想要更便宜一些的计算优化型实例,就可以去找c4系列和c3系列。

c5 适用于计算密集型的应用,科学计算,人工智能,分布式分析等。

%title插图%num

3 内存优化型有x1e,x1,r4,r3等,性能上x1e > x1 > r4 > r3. 性能与价格是呈正相关的,如果你想要更便宜的类型,可以去找相应的系列。

适用于高性能数据库,内存数据库,内存密集型应用。

%title插图%num

4 加速计算型,有p3,p2, g3(GPU系列,图形密集型),f1(FPGA系列,现场可编程门阵列) 

%title插图%num

适用于语音识别,无人驾驶,高性能计算等应用。

5 存储优化型,有h1(HDD), i3(SSD), d2(HDD)系列。

%title插图%num

适用于MapReduce,HDFS分布式文件系统,网络文件系统,日志和数据处理系统(Apache Kafka)等。

关于价格,肯定是性能越高,价格越高,但是对其基本类型大概需要多少钱有一个大概的认识会让你在预算,选择什么样的类型上有一定的把控。t2.medium大概一年$235,折合人民币大概1500块钱左右。m4.2xlarge大概一年$2026,一万多一年,看出来其实已经很贵了。c4.2xlarge大概一年$2078,h1.2xlarge 大概一年$3056, x1.16xlarge大概一年是$33601,一台用一年大概一年是二十多万,土豪我们做朋友吧。

————————————————

原文链接:https://blog.csdn.net/hongchangfirst/article/details/78831484

AWS API Gateway和Lambda的简单测试

文章目录
具体流程
创建Lambda应用
创建API Gateway
S3 Bucket网页测试触发API Gateway和Lambda函数
碰到S3 Bucket删除问题

测试了一下使用API Gateway来触发Lambda应用,并将结果显示在网页上。
Lambda支持语言为: Node.js,Java,Python,C#,Go,PowerShell,等等。它具有无需管理服务器,根据需求自动扩展,便宜等优势。
具体流程
在S3 Bucket里存放网页,显示网页后,在网页里通过API Gateway来触发Lambda功能应用,并将Lambda功能应用返回的结果显示在网页上。Route53来使用DNS网址为可选。

创建Lambda应用
Lambda是EC2在一起的Compute界面下,点进去后,再点Create Function来创建函数, 取名为:XiongLambdaFunction,语言设置为Python 3.6,这样会自动生成以下代码:
%title插图%num

进行以下替换:

%title插图%num

创建API Gateway
创建一个API Gateway,在Networking & Content Delivery下点API Gateway,选择
REST,API取名为:XiongTestAPI,在Actions下点Create Method,选择GET方法,Integration type选择Lambda Function,并选择前面已经创建的XiongLambdaFunction。点保存,有以下提示。

You are about to give API Gateway permission to invoke your Lambda function:
arn:aws:lambda:ap-southeast-1:606255748358:function:XiongLambdaFunction

点Deploy API对API进行发布,发布成功后会有一个URL生成,这个生成的URL将会被用做第三步测试:

Invoke URL: https://p9ciqi7imh.execute-api.ap-southeast-1.amazonaws.com/XiongReturnNameAPI

S3 Bucket网页测试触发API Gateway和Lambda函数
创建两个文件:Index.html和error.html,此测试是根据ACloud Guru所做的示例。
在index.html里,将GET请求的URL替换为: https://p9ciqi7imh.execute-api.ap-southeast-1.amazonaws.com/XiongReturnNameAPI,如下html代码所示:
%title插图%num

error.html

%title插图%num

创建一个S3 Bucket,取名为: xionglambdatest,在Properties下面进行设置,Static website hosting,创建了以下Endpoint, Index document设置为index.html,Error Document设置为error.html,保存。
Static website hosting
Endpoint : http://xionglambdatest.s3-website-ap-southeast-1.amazonaws.com

将前面创建的index.html和error.html进行上传,

如果你注册了域名的话,可以使用Route53来设置 A Record来指向S3 Bucket的Endpoint达到域名访问的目的。

这里直接测试:
Static website hosting
Endpoint : http://xionglambdatest.s3-website-ap-southeast-1.amazonaws.com

返回以下错误:

%title插图%num

在S3 Bucket xionglambdatest中,设置Make Public,确认,再试,可以成功访问。

点按钮无反应,在Chrome的Develop Tool里发现碰到以下错误:

%title插图%num

CORS在作怪,在Resource下里的Action里点Enable CORS,再试, 点按钮后,界面返回如下:

%title插图%num

说明https://p9ciqi7imh.execute-api.ap-southeast-1.amazonaws.com/XiongReturnNameAPI返回了{“statusCode”: 200, “headers”: {“Access-Control-Allow-Origin”: “*”}, “body”: “Xiong Huilin”}。

重新再试,在创建GET方法时,记得把Use Lambda Proxy integration选择项选上, 表明是Lambda返回值 。另外记得在Resource下里的Action里点Enable CORS, *后Deploy API。这次成功。

点按钮后,以下文字:
Hello 2nd December 2019!
变为:
Hello Xiong Huilin。
也就是https://p9ciqi7imh.execute-api.ap-southeast-1.amazonaws.com/XiongReturnNameAPI返回了Xiong Huilin,测试成功!

点完按钮的效果如下:
%title插图%num

碰到S3 Bucket删除问题
前面做Elastic Beanstalk测试的时候:AWS的CloudFormation和Elastic Beanstalk的简单测试,自动创建了名为elasticbeanstalk-ap-southeast-1-606255748358的S3 Bucket,删除时返回了Access Denied的错误。

参见: AWS Forum: can’t delete empty elasticbeanstalk created bucket

在以下Bucket Policy的JSON文件里将Deny改成Allow,就可以删除了,问题解决。
%title插图%num

参见Bucket Policy Examples,可以使用以下JSON文件设置Bucket Policy以达到Bucket为公共访问的目的:

%title插图%num

 

面向对象

之面向对象(类、私有属性、私有方法、静态方法、类方法、继承、多态、鸭子类型)

类(Class)
类的定义与使用
类的构造方法
类的属性与方法
私有属性与私有方法
静态方法与类方法
继承与多态
继承
多态
鸭子类型
类变量与实例变量的区别
类(Class)
类的定义与使用
类必须在被定义后才能使用,定义一个类也就是定义这一类对象的模板,定义它的属性和方法。python中提供了class关键字来声明一个类,class中有成员属性和成员方法。

类的格式:
class [类名]:
[语句块]

类的定义:
class NewClass:
pass
类的使用:
# 实例化类
new = NewClass()

类的构造方法
在创建实例时,很多类都需要特定的初始状态,所以一个类可以定义一个特殊的方法,叫做构造方法。在python中,构造函数就是类的__int__方法。当一个类定义了__int__方法,在类实例化是会自动调用__int__方法。
注意:构造方法的返回值必须是”None”

class Human:
def __init__(self):
print(‘我是人类’)

human = Human()
执行结果:
我是人类

类的属性与方法
属性:又称为成员变量或类变量,必须要使用”self”加上点的方式赋值,不能直接定义变量。直接定义的变量的生命周期只会在函数内,函数执行完变量就会被销毁。
class Human:
def __init__(self, name):
self.name = name #正确的定义变量方式
age = 3 #错误的定义变量方式

human = Human(‘周星驰’)
print(human.name)

执行结果:
周星驰

方法:在类中定义的函数称之为方法。类的方法和函数定义的方法基本相同,但方法一定要在类里并且*个参数必须是”self”
class Human:
def __init__(self, name):
self.name = name
# 方法
def run(self):
print(‘生命不息,运动不止’)

human = Human(‘周星驰’)
human.run()

执行结果:
生命不息,运动不止

私有属性与私有方法
私有属性:在上面的例子中可以看到实例可以获取和修改属性的值。但如果我们需要限制实例修改属性的话就要用到私有属性。定义私有属性只需要在定义属性名字的时候使用两条下划线作为开头,python解释器就认为这个属性时私有的,外部不能随便访问这个属性。
class Human:
def __init__(self, name):
self.__name = name

human = Human(‘周星驰’)
human.__name()

执行结果:
AttributeError: ‘Human’ object has no attribute ‘__name’

虽然我们在构造方法给”__name”赋值了,但是在实例中不能直接访问到这个私有变量。我们可以使用这个特效保护一些不想让用户随便修改的属性。
class Human:
def __init__(self):
self.__name = None

def set_name(self, name):
if not isinstance(name, str):
print(‘名字必须是字符串’)
return False
if len(name) > 4:
print(‘名字的字符数不嫩大于4!’)
return False
elif len(name) <= 0:
print(‘名字的字符数必须大于0!’)
return False
self.__name = name

def play(self):
print(‘我的名字是:’, self.__name)

human = Human()
human.set_name(1)
human.set_name(”)
human.set_name(‘阿姆斯特朗’)
human.set_name(‘周星驰’)
human.play()

执行结果:
名字必须是字符串
名字的字符数必须大于0!
名字的字符数不嫩大于4!
我的名字是: 周星驰

私有方法:私有方法与私有变量相似,也是只能在类内部被调用,实例不能直接调用。
class Human:
def __init__(self, name):
self.name = name

# 方法
def __run(self):
print(‘生命不息,运动不止’)

human = Human(‘周星驰’)
human.__run() #错误

执行结果:
AttributeError: ‘Human’ object has no attribute ‘__run’

静态方法与类方法
静态方法:与类变量有点相似,在定义类时就已经被分配好了,并不绑定类也不绑定实例,相当于给方法添加了一个前缀。定义静态方法需要加入装饰器语法”@staticmethod”。静态方法不再需要”self”,在调用时也不需要实例化。
class Human:
name = ‘周星驰’

@staticmethod
def run():
print(‘生命不息,运动不止’)

Human.run()

执行结果:
生命不息,运动不止

类方法:该方法绑定在定义的类上,而不是绑定在实例上。定义静态方法需要加入装饰器语法”@classmethod”,类方法都有一个初始的参数”cls”,这个参数指向的是定义的类本身,所有类方法可以读取和修改类变量。
class Human:
name = ‘周星驰’

@classmethod
def run(cls):
print(cls.name, ‘生命不息,运动不止’)

Human.run()

执行结果:
周星驰 生命不息,运动不止

继承与多态
面向对象编程具有三大特效:封装性、继承性、多态性。

继承
在一个类的基础上制定一个新类,这个类不仅可以继承原来类的属性和方法,还可以添加新的属性和方法。原来的类叫父类,新的类叫子类。python还支持多重继承,也就是说一个子类能继承多个父类。但子类不能调用父类的私有变量和私有方法。

class Human:
def __init__(self, name):
self.name = name

def eat(self):
print(‘人是铁,饭是钢’)

class YellowHuman(Human):
pass

yellow_human = YellowHuman(‘周星驰’)
yellow_human.eat()

执行结果:
人是铁,饭是钢

如上所示,”YellowHuman”这个类没有写”eat”方法,但是继承了”Human”类,所有就相当于拥有了”Human”类中的所有方法,执行”yellow_human.eat()“语句的结果为”人是铁,饭是钢”

多态
当子类和父类存在相同的方法时,子类的方法会覆盖父类的方法,这样的代码在运行时总是会调用子类的方法,这就是多态

class Human:
def __init__(self, name):
self.name = name

def run(self):
print(‘生命不息,运动不止’)

class YellowHuman(Human):
def run(self):
print(‘生命在于运动’)

class BlackHuman(Human):
def run(self):
print(‘你想拥有强壮的肌肉吗’)

yellow_human = YellowHuman(‘周星驰’)
yellow_human.run()
balck_human = BlackHuman(‘巨石强森’)
balck_human.run()

执行结果:
生命在于运动
你想拥有强壮的肌肉吗

鸭子类型
鸭子类型(Duck Typing)是动态类型的一种风格。在这种风格中,一个对象有效的语义,不是有继承自特定的类或实现特定的接口决定的,而是由当前方法和属性的集合决定的。
鸭子类型通常得意于不测试方法和函数得到类型,而是依赖文档、清晰的代码和测试来确保正常使用。从静态类型语言转向动态类型语言的用户通常试图添加一些静态的类型检查,从而影响了鸭子类型的益处和可升缩性,并约束了语言的动态特性。

class YellowHuman:
def run(self):
print(‘生命在于运动’)

class BlackHuman:
def run(self):
print(‘你想拥有强壮的肌肉吗’)

def human_run(human):
human.run()

yellow_human = YellowHuman()
balck_human = BlackHuman()

human_run(yellow_human)
human_run(balck_human)

执行结果:
生命在于运动
你想拥有强壮的肌肉吗

这个例子中虽然没有使用继承,但是我们任然可以实现”多态”,这也是”多态”的一种实现方式。

类变量与实例变量的区别
类变量:不需要实例化就能直接使用,相当于绑定在类上,而不是绑定在实例上。但是类变量在实例中也是可以被调用的。可在类的所有实例之间共享的值

class Human:
name = ‘名字’ #类变量

print(Human.name)
human = Human()
print(human.name)

执行结果:
名字
名字

实例变量:实例化之后,每个实例单独拥有的变量。

class Human:
def __init__(self, name):
self.name = name #实例变量

human = Human(‘名字’)
print(human.name)

执行结果:
名字

类变量和实例变量的区别在于:类变量是所有对象共有,其中一个对象将它值改变,其他对象得到的就是改变后的结果;而实例变量则属对象私有,某一个对象将其值改变,不影响其他对

预测分析·民宿价格预测baseline

预测分析·民宿价格预测baseline

预测分析·民宿价格预测比赛是和鲸社区与ChallengeHub联合举办的一场新手赛,本文旨在多角度构建特征工程来帮助选手快速比赛上手。
比赛链接
话不多说,直接开!

导入相关库
import time
import lightgbm as lgb
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn import metrics
from sklearn.model_selection import KFold
from sklearn.preprocessing import LabelEncoder
from catboost import CatBoostRegressor, Pool

#读取训练集与测试集并构建原始数据
train = pd.read_csv(‘./训练集.csv’)
test = pd.read_csv(‘./测试集.csv’)
df_features = train.append(test)

填充缺失值并且相关Encoding操作
df_features[‘洗手间数量’].fillna(-1, inplace=True)
df_features[‘床的数量’].fillna(-1, inplace=True)
df_features[‘卧室数量’].fillna(-1, inplace=True)
df_features[‘房主是否有个人资料图片’].fillna(‘na’, inplace=True)
df_features[‘房主身份是否验证’].fillna(‘na’, inplace=True)
df_features[‘房主回复率’].fillna(‘-1’, inplace=True)
df_features[‘房主回复率’] = df_features[‘房主回复率’].astype(str).apply(lambda x: x.replace(‘%’, ”))
df_features[‘房主回复率’] = df_features[‘房主回复率’].astype(int)
df_features[‘民宿周边’].fillna(‘na’, inplace=True)
mean_score = df_features[‘民宿评分’].mean()
df_features[‘民宿评分’].fillna(mean_score, inplace=True)
df_features[‘邮编’].fillna(‘na’, inplace=True)

for feat in [‘房主是否有个人资料图片’, ‘房主身份是否验证’, ‘民宿周边’, ‘邮编’]:
lbl = LabelEncoder()
lbl.fit(df_features[feat])
df_features[feat] = lbl.transform(df_features[feat])

def freq_enc(df, col):
vc = df[col].value_counts(dropna=True, normalize=True).to_dict()
df[f'{col}_freq’] = df[col].map(vc)
return df

for feat in [‘容纳人数’, ‘洗手间数量’, ‘床的数量’, ‘床的类型’,
‘卧室数量’, ‘取消条款’, ‘所在城市’, ‘清洁费’,
‘房主是否有个人资料图片’, ‘房主回复率’, ‘是否支持随即预订’,
‘民宿周边’, ‘房产类型’, ‘房型’, ‘邮编’]:
df_features = freq_enc(df_features, feat)

对时间特征进行处理
# 时间特征处理
from tqdm import tqdm
df_features[‘首次评论日期’] = pd.to_datetime(df_features[‘首次评论日期’]).values.astype(np.int64) // 10 ** 9
df_features[‘何时成为房主’] = pd.to_datetime(df_features[‘何时成为房主’]).values.astype(np.int64) // 10 ** 9
df_features[‘*近评论日期’] = pd.to_datetime(df_features[‘*近评论日期’]).values.astype(np.int64) // 10 ** 9

df_features[‘timestamp_diff1’] = df_features[‘首次评论日期’] – df_features[‘何时成为房主’]
df_features[‘timestamp_diff2’] = df_features[‘*近评论日期’] – df_features[‘首次评论日期’]
df_features[‘timestamp_diff3’] = df_features[‘*近评论日期’] – df_features[‘何时成为房主’]

def brute_force(df, features, groups):
for method in tqdm([‘max’, ‘min’, ‘mean’, ‘median’, ‘std’]):
for feature in features:
for group in groups:
df[f'{group}_{feature}_{method}’] = df.groupby(group)[feature].transform(method)

return df

dense_feats = [‘timestamp_diff1’, ‘timestamp_diff2’, ‘timestamp_diff3’]
cate_feats = [‘房型’]

df_features = brute_force(df_features, dense_feats, cate_feats)

其他简单业务特征
def f(x):
if x>0:
return 1
else:
return 0
df_features[‘if_bed’] = train[‘床的数量’].apply(f)
df_features[‘if_bedroom’] = train[‘卧室数量’].apply(f)
df_features[‘if_wc’] = train[‘洗手间数量’].apply(f)

#交叉衍生特征
df_features[‘人均床数量’] = df_features[‘容纳人数’] / (df_features[‘床的数量’] + 1e-3) # 1e-3 是为了避免 zero-divide
df_features[‘人均卧室量’] = df_features[‘容纳人数’] / (df_features[‘卧室数量’] + 1e-3)
df_features[‘卧室床均量’] = df_features[‘床的数量’] / (df_features[‘卧室数量’] + 1e-3)
df_features[‘经纬度平方根’] = (df_features[‘维度’]*df_features[‘维度’] + df_features[‘经度’]*df_features[‘经度’])**.5

def get_features(df):
features = [[‘人均床数量’,’人均卧室量’],[‘卧室床均量’,’人均卧室量’]]
for fea in features:
df[f'{fea[0]}_{fea[1]}_std’] = df[fea].std(1)
df[f'{fea[0]}_{fea[1]}_max’] = df[fea].max(1)
df[f'{fea[0]}_{fea[1]}_min’] = df[fea].min(1)

df[f'{fea[0]}_{fea[1]}_sub’] = df[fea[0]] – df[fea[1]]

#df.loc[df[fea[0]] <= df[fea[1]],f'{fea[0]}_{fea[1]}_mark’] = 0
#df.loc[df[fea[0]] > df[fea[1]],f'{fea[0]}_{fea[1]}_mark’] = 1
return df

df_features = get_features(df_features)

对“便利设施”特征进行挖掘
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
df_features[‘便利设施数量’]=df_features[‘便利设施’].apply(lambda x:len(x.lstrip(‘{‘).rstrip(‘}’).split(‘,’)))
df_features[‘便利设施’] = df_features[‘便利设施’].apply(
lambda x: x.replace(‘{‘, ”).replace(‘}’, ”).replace(‘”‘, ”).replace(‘:’, ”).replace(‘,’, ‘ ‘))
# df_features[‘便利设施’] = df_features[‘便利设施’].str.lower()

n_components = 12

X = list(df_features[‘便利设施’].values)
tfv = TfidfVectorizer(ngram_range=(1,1), max_features=10000)
tfv.fit(X)
X_tfidf = tfv.transform(X)
svd = TruncatedSVD(n_components= n_components)
svd.fit(X_tfidf)
X_svd = svd.transform(X_tfidf)

for i in range(n_components):
df_features[f’便利设施_tfidf_{i}’] = X_svd[:, i]

获取特征和标签数据
df_train = df_features[~df_features[‘价格’].isnull()]
df_train = df_train.reset_index(drop=True)
df_test = df_features[df_features[‘价格’].isnull()]

no_features = [‘数据ID’, ‘价格’, ‘便利设施’]
# 输入特征列
features = [col for col in df_train.columns if col not in no_features]

X = df_train[features] # 训练集输入
y = df_train[‘价格’] # 训练集标签
X_test = df_test[features] # 测试集输入

五折Catboost模型
n_fold = 5
folds = KFold(n_splits=n_fold, shuffle=True, random_state=1314)

oof = np.zeros(len(X))
prediction = np.zeros(len(X_test))
for fold_n, (train_index, valid_index) in enumerate(folds.split(X)):
X_train, X_valid = X[features].iloc[train_index], X[features].iloc[valid_index]
y_train, y_valid = y[train_index], y[valid_index]
cate_features=[‘房主是否有个人资料图片’,’房主身份是否验证’,’是否支持随即预订’,’房产类型’,
‘房型’,’if_bed’,’if_bedroom’,’if_wc’]
train_pool = Pool(X_train, y_train, cat_features=cate_features)
eval_pool = Pool(X_valid, y_valid, cat_features=cate_features)
cbt_model = CatBoostRegressor(iterations=10000, # 注:baseline 提到的分数是用 iterations=60000 得到的,但运行时间有点久
learning_rate=0.1, # 注:事实上好几个 property 在 lr=0.1 时收敛巨慢。后面可以考虑调大
eval_metric=’SMAPE’,
use_best_model=True,
random_seed=42,
logging_level=’Verbose’,
#task_type=’GPU’,
devices=’0′,
gpu_ram_part=0.5,
early_stopping_rounds=400)

cbt_model.fit(train_pool,
eval_set=eval_pool,
verbose=1000)

y_pred_valid = cbt_model.predict(X_valid)
y_pred = cbt_model.predict(X_test)
oof[valid_index] = y_pred_valid.reshape(-1, )
prediction += y_pred
prediction /= n_fold

from sklearn.metrics import mean_squared_error
score = mean_squared_error(oof, df_train[‘价格’].values, squared=False)
print(score)

test[‘价格’] = prediction
test[[‘数据ID’, ‘价格’]].to_csv(‘./sub_cat.csv’.format(score), index=None)

*后线上RMSE可以达到5.3以内,目前可以排到top10左右。
本文主要参考了官方的baseline以及恒哥的代码思路

试用AWS的Lambda和API Gateway

目标
使用Lambda和API gateway搭建一个HTTP API,返回文本信息

步骤
在Lambda中创建nodejs函数

函数名 helloWorld

函数体:

%title插图%num

%title插图%num

在API Gateway中创建API访问Lambda函数

%title插图%num

点击“Create Resource”按钮

%title插图%num

取名字“hello”

%title插图%num

选择“Lambda Function”,并选择在前面创建的helloWorld函数

%title插图%num

系统会显示一个系统内部响应的示意图。 点击“TEST”按钮

%title插图%num

点击“TEST”

%title插图%num
在Response Body中显示了预期的结果

%title插图%num

使用浏览器访问也能显示相同的结果

%title插图%num

————————————————

原文链接:https://blog.csdn.net/aws0to1/article/details/46990313

如何为企业选择*理想的Linux服务器系统?

相对于成百上千种Linux桌面系统,Linux服务器系统的数量其实比较有限,但我们仍然很难从中选择真正适合企业需求的理想方案。在本文中,我将尝试运用自己积累了十二年的Linux使用经验帮助大家找到问题的答案。

我认为,选择Linux服务器系统时*重要的一项因素在于,您的IT员工是否拥有娴熟的Linux使用经验。尽管时至今日,Linux专业知识已经不再像过去那样晦涩难懂,但要想成为精通Linux的IT专家,普通技术人员还有很长的路要走。

在参与今年早些时候于俄勒冈州波特兰举办的OSCon(即世界开源商务大会)时,我发现每一家企业(甚至包括微软在内)都在寻找拥有丰富Linux及开源使用经验的技术人员。

事实上,目前雇主很难找到已经在Linux领域打混过几年以上的成熟员工——而这类技术人员正是大家按计划顺利使用Linux服务器的必备人才。

换句话来说,如果各位手下欠缺这类Linux老鸟,*好还是别头脑发热部署什么Linux服务器发行版。就以Debian为例,这套系统根本没有专门的厂商提供技术支持,更不用说相关培训了。

请不要误会我的意思。Debian对于经验丰富的使用者来说*为强大,但如果大家手底下的技术团队连BASH与C Shell之间的区别都弄不清,还是早点断了使用Debian的念想吧。

*适合新人使用的Linux服务器系统方案

RHEL
SUSE
Oracle Linux
Turnkey Linux
如果您的技术团队刚刚接触Linux,各位*好还是选择商用Linux较为妥当。在这里,我会跟大部分咨询人士一样向您推荐红帽企业Linux。

如果没有企业技术支持,红帽根本不可能成为*家凭借Linux产品获得十亿身家的公司。与其它Linux版本相比,RHEL所提供的工具类型非常全面——企业支持、专业认证、硬件认证以及通过红帽网络(简称RHN)实现的自动化在线更新——这一切都会令CFO与CIO们喜笑颜开。

不过红帽还面对着另一位实力强劲的竞争对手:SUSE Linux企业服务器系统(简称SLES)。

与RHEL类似,SLES也提供技术支持;兄弟公司Novell负责员工认证;硬件认证与在线更新也一样不少。

这么说来,我们该如何从二者当中做出选择?答案很简单:做测试。二者的测试流程都很简单易行且完全免费。从个人角度讲,RHEL与SLES两种方案我都有所涉猎。要做出正确选择,大家需要在企业需求与系统特性之间找到契合点。只要出发点准确,二者一般都能发挥理想的作用。

其实还有另一套企业级Linux选项:甲骨文Linux虽然它的所有设计思路与技术目标都在照搬RHEL,但我个人对此倒并不在意。不过需要提醒大家的是,根据我自己的经历,只有那些把所有IT赌注都押在甲骨文一家身上的企业才会使用这套系统。

*适合非专家级技术人员使用的Linux服务器系统

CentOS
openSUSE
Ubuntu Server
下面我们来探讨这种不上不下的状况。您的员工对Linux系统拥有一定了解,但还达不到专家级水准——这时该怎么办?

对于这样的企业用户,我当然准备了一些相关推荐。首先,如果大家喜欢RHEL的运作方式,那么CentOS作为RHEL的免费克隆版肯定能让您满意。

CentOS的人气很高。如果大家在几乎全部Web托管服务中使用Apache Web服务器,那么就相当于已经在基础设施内运行着CentOS。另外,这款发行版也提供大量免费的在线支持资源。

如果大家担心红帽公司有可能对CentOS来一招釜底抽薪,我请各位还是不要杞人忧天的好。尽管红帽对甲骨文Linux的存在表示反感,但红帽公司CEO James Whitehurst*近刚刚表示:“CentOS已经成为RHEL生态系统当中的默认组成部分。它的存在帮助我们开拓了新领域,即以免费方式让用户体验RHEL的功效。因此,虽然从微观角度看我们的营收受到了影响,但就宏观角度说CentOS对于红帽Linux起到了*为重要的推动意义。”

对于对Linux有所了解但还不够深入的用户而言,OpenSUSE也是个不错的选择。OpenSUSE是SUSE系统的社区Linux发行版。尽管它并不提供像SLES那样的技术支持,但其出色的稳定性与易用性仍然值得赞赏。另外,我自己家里的服务器使用的就是OpenSUSE系统。

不过我并不推荐RHEL社区推出的另一位小兄弟——Fedora。Fedora对于希望将Linux潜力推向*限的开发人员来说非常出色,但它并不适合充当以稳定为主要诉求的服务器系统。

另一套理想方案是由Canonical公司推出的Ubuntu。尽管Ubuntu在大家印象中是一款*具野心、甚至打算向智能手机及平板设备扩展的桌面系统,但它在服务器环境中还拥有另一个出色的版本:Ubuntu Server。

与RHEL及SLES类似,Ubuntu也提供技术支持与产品认证,但其资源储备不像红帽及SUSE那样丰富。不过从另一方面讲,Ubuntu在执行简单服务器任务时更易于打理。

*适合专家级用户的Linux服务器系统

Arch
Gentoo
Debian
Fedora
如果大家对云计算兴趣深厚,那么别忘了Ubuntu(RHEL也一样)可与OpenStack深入对接的能力。另外,作为Ubuntu系统的母公司,Canonical还推出了Juju,一款非常便捷的DevOps(也就是针对开发与运营流程)的工具集,从而让过去那些令人抓狂的服务器服务设置、配置、管理、维护、部署以及扩展等工作变得轻松愉快。

说起云计算,大家应该首先考虑自己的Linux服务器到底是要运行在自己的办公楼当中还是数据中心内。如果选择了云方案,大家需要保证业务服务运行在专门的Linux服务器之上。

大部分公共云服务,例如Amazon Web Services(简称AWS)、Azure以及RackSpace,都提供Linux服务器方案。如果使用这类方案,大家可以免去服务器设置过程中的大量技术难题。

举例来说,Amazon在自家Amazon弹性云(简称AE2)中为前文所提到的所有Linux发行版都提供了Amazon设备镜像(简称AMI),甚至还包括他们自己开发的Amazon Linux。而且别惊讶,就连微软的Azure也支持CentOS、OpenSUSE、SUSE以及Ubuntu。*后,RackSpace与OpenStack支持大多数主流服务器Linux发行版以及知名度相对较低的Arch与Gentoo。不过我还是要强调,只有Linux技术水平达到一定程度的用户才适合使用Debian,而且其发行版应该只用于特定关键性业务服务器。

谁说在云环境中我们仍然需要一台性能强劲的Linux服务器?事实上,只要保证每套Linux服务器都能专门对应一种特定工作,其整体表现就完全能够令人满意。说到这里,*后一位候选者终于上台了——这就是Turnkey Linux。

Turnkey以64位Debian Linux为基础进行开发,但它对于企业用户的要求其实非常友好。究其原因,在于它提供的一套专用型Linux服务器方案,而非全功能式发行版。

Turnkey提供超过一百种可以直接运行的应用程序。其中包括Apache Web服务等标准;一套Linux、MySQL、PHP/Python/Perl(简称LAMP)堆栈;一款WordPress博客平台;针对Ushahidi紧急状况应对服务器等特殊业务环境的Drupal内容管理系统(简称CMS);游戏化客户关系管理(简称CRM)应用Zurmo;人为响应管理系统Sahana Eden等等。大家可以将这些专有应用服务器运行在AWS、裸机、虚拟机或者基础设施即服务(简称IaaS)云当中。

总而言之,无论是对Linux一无所知的新手还是深谙内核奥秘的开发达人,总有一款适合您自己及所在企业的Linux服务器系统——请尽情选择吧。

语法概述

语法概述

1.1 格式框架
1.1.1 缩进
Python 语言采用严格的 “缩进” 来表明程序的格式框架。缩进用来表示代码之间的包含和层次关系,它是 Python 语言中表明程序框架的唯一手段。PEP 8 指南建议使用四个空格表示一个缩进,这既提高了可读性,又留下了足够的多级缩进空间。

在字处理文档中,通常被广泛使用的是制表符,而不是使用空格来完成缩进。对于字处理文档来说,这样做的效果很好,但混合使用制表符和空格会让 Python 解释器感到迷惑。好在每款编辑器都提供了一种功能,可以将输入的制表符转换为指定数量的空格。因此,在编写代码时*对应该使用制表符键,但一定要对编辑器进行设置,使其在文档中插入空格而不是制表符。

1.1.2 注释
注释是代码中的辅助性文字,用以在程序中使用自然语言进行解释说明。Python 语言采用 # 表示一行注释的开始,多行注释需要在每行开始都使用 #。PEP 8 建议注释的行长不应超过 72 字符。

严格地讲,Python 并未提供多行注释。但可以使用成对的三个单引号 ”’ 或双引号 “”” 来实现多行注释的功能。事实上, ”’ 或 “”” 在 Python 中用来完成文档注释。

1.1.3 续行符
Python 程序是逐行编写的,每行代码的长度并无限制。但单行代码太长会不利于阅读,PEP 8 建议每行不超过 80 个字符。

在 Python 中可以使用续行符将单行代码分割成多行代码,Python 中的续行符为 \,续行符后应直接换行。列表、元组、字典中的元素之间不使用续行符也可以直接换行。

在大多数的开发软件中,都可以设置一个视觉标志,通常是一条垂直参考线,让你知道不能越过的界限在什么地方。

1.1.4 空行
要将程序的不同部分分开,可使用空行。空行与代码缩进不同,它并不是 Python 语法的一部分。即使书写时不插入空行,也不会出现语法错误。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。因此,空行也是程序代码的重要部分。

通常,函数之间或类中的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

1.2 基本语法元素
1.2.1 变量与常量
变量是保存和表示数据值的一种语法元素。变量的值可以改变,能够通过赋值方式被修改。变量的标识符通常全部使用小写字母,单词之间使用下划线连接。

常量是一种特殊的变量,其值在程序的整个生命周期内保持不变。通常使用全部大写变量名的方式来指出应将该变量视为常量。相比于直接使用字面值而言,为常量指定一个有意义的名称,可以更清晰地表达出它的用途。

1.2.2 标识符
Python 语言允许使用大写字母、小写字母、数字、下划线和汉字等字符及其组合给变量、函数、类等命名,即标识符。标识符的长度没有限制,首字符不能是数字,中间不能出现空格。

注意:Python 对大小写敏感,例如 message 和 Message 是两个不同的标识符。

1.2.3 保留字
保留字,也称为关键字,指被编程语言内部定义并保留使用的标识符。程序员编写程序不能定义与保留字相同的标识符。每种程序设计语言都有一套保留字,保留字一般用来构成程序的整体框架、表达关键值和具有结构性的复杂语义等。

1.3 基本语句元素
1.3.1 表达式
产生或计算新数据值的代码片段称为表达式。表达式类似数学中的计算公式,运算后产生运算结果,运算结果的类型由操作符或运算符决定。表达式一般由数据和操作符等构成,是构成 Python 语句的重要部分。

1.3.2 赋值语句
Python 语言中,= 表示 “赋值”,即将等号右侧的值计算后将结果值赋给左侧变量,包含等号 = 的语句称为 “赋值语句”。格式为:

<变量> = <表达式>

还可以使用同步赋值语句同时给多个变量赋值,格式为:

<变量 1>, …, <变量 N> = <表达式 1>, …, <表达式 N>

1.3.3 分支与循环
分支语句的作用是根据判断条件选择程序执行路径,包括单分支、二分支和多分支。

循环语句与分支语句控制程序执行类似,它的作用是根据判断条件确定一段程序是否再次执行一次或者多次。循环语句包括遍历循环和条件循环。

1.4 数据类型概述
1.4.1 数字类型
Python 中的数字类型有整数、浮点数、复数,分别和数学中的整数、小数、复数相对应。不同的数字类型可以直接计算。可以把 IDLE 当作一个计算器使用:

>>> 1 + 2
3
>>> 3 – 2
1
>>> 2 * 3
6
>>> 3 / 2
1.5
>>> 3 ** 2
9
>>> 3 ** 0.5
1.7320508075688772
>>> 2 + 3*4
14
>>> (2 + 3) * 4
20

1.4.2 字符串
字符串是字符的序列表示,根据字符串的内容多少分为单行字符串和多行字符串。单行字符串由一对单引号 ‘ 或双引号 ” 作为边界来表示,多行字符串由一对三单引号 ”’ 或三双引号 “”” 作为边界来表示。

在 Python 中,单引号和双引号都用来表示字符串。这种设计的好处是可以在字符串中很轻松地包含引号和撇号:

>>> print(‘I tlod my friend, “Python is interesting.”‘)
I tlod my friend, “Python is interesting.”
>>> print(“She’s my best friend.”)
She’s my best friend.

还有一种特殊的字符串是转义字符。Python 语言的转义符为 \,其与后面相邻的一个字符共同组成了新的含义。如:\n 表示换行、\\ 表示反斜杠、\’ 表示单引号、\” 表示双引号、\t 表示制表符。

字符串是一个字符序列。字符串*左端位置标记为 0,向右依次增加;*右端位置标记为 -1,向左依次递减。对字符串中某个字符的检索被称为索引。索引的使用方式为:

<字符串或字符串变量>[序号]

>>> ‘hello'[0]
‘h’
>>> ‘hello'[3]
‘l’
>>> ‘hello'[-2]
‘l’

Python 中的字符串以 Unicode 编码存储,字符串的英文字符和中文字符都算作 1 个字符。

对字符串中某个子串或区间的检索被称为切片。切片的使用方式为:

<字符串或字符串变量>[N: M]
1
切片将会返回字符串的第 N 个到第 M 个字符,不包含末尾的 M 个字符。

>>> ‘hello'[1: 3]
‘el’
>>> ‘hello'[1:] # 检索区间到*后一个字符结束
‘ello’
>>> ‘hello'[: 3] # 检索区间从 0 开始
‘hel’
>>> ‘hello'[:] # 返回字符串副本
‘hello’

此外,还可以在切片时指定步长:

<字符串或字符串变量>[N: M: K]
1
>>> ‘hello'[::2]
‘hlo’
>>> ‘hello'[::-1]
‘olleh’
>>> ‘hello'[1: 3: 2]
‘e’

1.4.3 列表与元组
列表、元组以及字符串在 Python 中同属于序列类型。序列类型是一维元素向量,元素之间存在先后关系,通过序号访问。因此,上述对字符串的索引、切片操作同样适用于列表及元组类型。

字符串类型可以看成是字符的有序组合。列表则是一个可以使用多种类型元素的序列类型,由方括号[]表示,列表中的元素可以进行修改。

>>> pets = [‘dog’, ‘cat’, ‘rabbit’] # 创建列表
>>> pets[1] = ‘parrot’ # 修改列表
>>> pets
[‘dog’, ‘parrot’, ‘rabbit’]

元组可以被视为一种特殊的列表,它使用圆括号来表示,元组中的元素不能被更改。

>>> pets = (‘dog’, ‘cat’, ‘rabbit’)
>>> pets[0] = ‘goldfish’
Traceback (most recent call last):
File “<pyshell#5>”, line 1, in <module>
pets[0] = ‘goldfish’
TypeError: ‘tuple’ object does not support item assignment

对于序列类型,有一些通用的操作:

x in s:如果 x 是 s 的元素,返回 True,否则返回 False。

x not in s:如果 x 不是 s 的元素,返回 True,否则返回 False。

s + t:连接 s 和 t。

s * n 或 n * s:将序列 s 复制 n 次。

len(s):返回序列 s 的元素个数(长度)。

min(s):返回序列 s 中的*小元素。

max(s):返回序列 s 中的*大元素。

sorted(s):对 s 的元素进行顺序排序,并以列表的形式返回结果。如果需要逆序排序,传递参数 reverse=True 即可。

s.index(x):返回序列 s 中*次出现元素 x 的位置。

s.count(x):返回序列 s 中出现 x 的总次数。

1.4.4 集合与字典
Python 语言中的集合类型与数学中的集合概念一致,即包含 0 个或多个数据项的无序组合,用大括号 {} 表示。因为集合是无序的,所以没有索引和位置的概念。集合中的元素可以进行增删。

集合中的元素类型只能是固定数据类型,例如:整数、浮点数、字符串、元组等,而列表、字典和集合类型本身都是可变数据类型,不能作为集合的元素出现。

>>> S = {2.71, ‘dog’, (1, 2)}
>>> S
{2.71, (1, 2), ‘dog’}

从上面的程序可以看到,集合的打印效果与定义顺序并不一致,因为集合元素是无序的。

字典是一种映射类型,使用 “键值对” 组织数据。这种组织数据的方式广泛应用在 Web 系统中。键值对的基本思想是将 “值” 信息关联一个 “键” 信息,进而通过键信息查找对应的值信息,这个过程叫映射。Python 语言中通过字典类型实现映射。

Python 语言中的字典使用大括号 {} 建立,每个元素是一个键值对,使用方式如下:

{<键 1>: <值 1>, <键 2>: <值 2>, …, <键 n>: <值 n>}

其中,键和值通过冒号连接,不同的键值对通过逗号隔开。从 Python 3.7 开始,字典中元素的排列与定义时相同。如果将字典打印出来或遍历其元素,将发现元素的排列顺序与添加顺序相同。

字典有时会存储众多的数据,因此可以使用多行来定义一个字典。例如下面的字典存储了每个人*喜欢的编程语言:

favourite_languages = {
‘jen’: ‘python’,
‘sarch’: ‘c’,
‘edward’: ‘ruby’,
‘phil’: ‘python’,
}

如上代码所示,*后一个键值对的后面也添加了逗号,这样做的好处是可以为添加下一行键值对时做好准备。

列表类型采用元素的位置进行索引。在字典的键值对元素中,键是值的索引,因此,可以直接利用键值对关系索引元素。字典中键值对的索引模式如下,采用中括号格式:

<值> = <字典变量>[<键>]

>>> d = {“01”: “小明”, “02”: “小红”, “03”: “小白”}
>>> d[“02”]
小红

利用索引和赋值操作配合,可以对字典中每个元素进行修改:

>>> d = {“01”: “小明”, “02”: “小红”, “03”: “小白”}
>>> d[“02”] = “阿红”
>>> d
{’01’: ‘小明’, ’02’: ‘阿红’, ’03’: ‘小白’}

通过索引和赋值配合,还可以向字典中增加元素:

>>> d = {}
>>> d[“04”] = “小新”
>>> d
{’04’: ‘小新’}

对于字典中不再需要的信息,可以使用 del 语句将相应的键值对彻底删除。使用 del 语句时,必须指定字典名和要删除的键。

>>> d = {“01”: “小明”, “02”: “小红”, “03”: “小白”}
>>> del d[“03″]
>>> d
{’01’: ‘小明’, ’02’: ‘小红’}

1.5 基本输入输出函数
1.5.1 input() 函数
input() 函数用以从控制台获得用户的一行输入,无论用户输入什么内容,input() 函数都以字符串类型返回。input() 函数可以包含一些提示性文字,用来提示用户。格式为:

<变量> = input(<提示性文字>)

name = input(‘能告诉我你的名字吗:’)
print(f’你好,{name}。’)
————————————————————————
能告诉我你的名字吗:John Lennon
你好,John Lennon。

有时候,提示信息可能有多行。可以先把提示信息赋值给一个变量,再把这个变量传递给函数 input():

prompt = ‘可以告诉我你的名字吗?’
prompt += ‘\n我将告诉你一个秘密。’
name = input(prompt)
print(f'{name}, 你将永远被人铭记。’)
————————————————————————
可以告诉我你的名字吗?
我将告诉你一个秘密。John Lennon
John Lennon, 你将永远被人铭记。

也可以使用多行字符串来表示提示信息:

prompt = ”’可以告诉我你的名字吗?
我将告诉你一个秘密。”’

1.5.2 eval() 函数
eval() 函数是 Python 语言中一个十分重要的函数,它能够以 Python 表达式的方式解析并执行字符串,将返回结果输出。

eval() 函数经常和 input() 函数一起使用,用来获取用户输入的数字,使用方式为:

<变量> = eval(input(<提示性文字>))

1.5.3print() 函数
print() 函数用于输出运算结果,根据输出内容的不同,有三种用法。

*种,仅用于输出字符串,使用方式为:

print(<待输出字符串>)

print(‘世界和平’)
————————————————————————
世界和平

如果 print() 函数中的字符串很长,可以在合适的位置分行。只需要在每行末尾都加上引号,同时对于除*行以外的其他各行,都在行首加上引号并缩进。

print(“话语不断涌出心头,像无止尽的雨浸入纸杯。”
“雨水倾泻,纷纷划过天际。”)
————————————————————————
话语不断涌出心头,像无止尽的雨浸入纸杯。雨水倾泻,纷纷划过天际。

第二种,仅用于输出一个或多个变量,使用方式为:

print(<变量 1>, <变量 2>, …, <变量 n>)

value = 123.456
print(value, value, value)
————————————————————————
123.456 123.456 123.456

第三种,用于混合输出字符串与变量值,使用方式为:

print(<输出字符串模板>.format(<变量 1>, <变量 2>, …, <变量 n>))

a, b = 123.456, 1024
print(“数字 {} 和数字 {} 的乘积是 {}”.format(a, b, a*b))
————————————————————————
数字 123.456 和数字 1024 的乘积是 126417.944

print() 函数输出完文本后会默认换行,如果不希望换行,或者希望在文本后增加其他内容,可以对 print() 函数的 end 参数进行赋值。格式为:

print(<待输出内容>, end=”<增加的输出结尾>”)

>>> a = 24
>>> print(a, end=”.”)
24.
>>> print(a, end=”%”)
24%

end 的值为空字符串 ” 时,表示将前后输出的字符串在同一行连续显示。

for i in range(1, 10):
print(i, end=”)

AWS Lambda 常见问题

一般性问题

  • 问:什么是 AWS Lambda?
    • 通过 AWS Lambda,无需配置或管理服务器即可运行代码。您只需按消耗的计算时间付费 – 代码未运行时不产生费用。借助 Lambda,您几乎可以为任何类型的应用程序或后端服务运行代码,而且全部无需管理。只需上传您的代码,Lambda 会处理运行和扩展高可用性代码所需的一切工作。您可以将您的代码设置为自动从其他 AWS 服务触发,或者直接从任何 Web 或移动应用程序调用。
  • 问:什么是无服务器计算?
    • 借助无服务器计算,您无需考虑服务器,即可构建和运行应用程序与服务。借助无服务器计算,您的应用程序仍在服务器上运行,但所有服务器管理工作均由 AWS 来完成。AWS Lambda 是无服务器计算的核心,支持您运行代码,且无需预置或管理服务器。
  • 问:什么时候应该使用 AWS Lambda 与 Amazon EC2?
    • Amazon Web Services 提供一组计算服务以满足各种需求。
    • Amazon EC2 具有范围广泛的实例类型以及自定义操作系统、网络和安全设置以及整个软件堆栈的选项,可提供灵活性,从而让您能够将现有的应用程序轻松迁移到云中。使用 Amazon EC2,您将负责预配置容量、监控服务器队的运行状况和性能,并设计容错性和可扩展性。AWS Elastic Beanstalk 提供易用的服务,供您部署和扩展 Web 应用程序,您可以在其中保留对底层 EC2 实例的所有权和完整控制权。Amazon EC2 Container Service 是一项可扩展的管理服务,支持 Docker 容器,允许您轻松地在 Amazon EC2 实例的托管群集上运行分布式应用程序。
    • AWS Lambda 可用于依照对事件的响应轻松执行代码,如 Amazon S3 存储桶的更改、Amazon DynamoDB 表的更新或您的应用程序或设备生成的自定义事件。利用 Lambda,您不必预配置您自己的实例;Lambda 会代您执行所有的运行和管理活动,包括容量预配置、监控服务器队运行状况、向底层计算资源应用安全补丁、部署您的代码、在前端运行 Web 服务以及监控和记录您的代码。AWS Lambda 为您的代码提供轻松的扩展和高可用性,从而无需您做额外努力。
  • 问:什么类型的代码可在 AWS Lambda 上运行?
    • AWS Lambda 提供了一种简单的方式来完成云中的许多活动。例如,您可以使用 AWS Lambda 构建以下内容:可以检索并转换 Amazon DynamoDB 中数据的移动后端,当对象上传到 Amazon S3 以后对其进行压缩或转换的处理程序,用于任意 Amazon Web Service 的 API 调用的审核和报告功能,使用 Amazon Kinesis 进行的流数据免服务器处理。
  • 问:AWS Lambda 支持哪些语言?
    • AWS Lambda 支持用 Node.js (JavaScript)、Python、Java (兼容 Java 8) 和 C# (.NET Core) 编写的代码。您的代码中可包含现有的库,甚至是本机库。有关使用 Node.js、Python、Java 和 C# 的信息,请参阅我们的文档。
  • 问:我能否访问 AWS Lambda 运行所在的基础设施?
    • 否。AWS Lambda 会代您运行计算基础设施,从而执行运行状况检查、应用安全补丁和执行其他例行维护。
  • 问:AWS Lambda 如何隔离我的代码?
    • 每个 AWS Lambda 函数都运行在其自己的环境中,有其自己的资源和文件系统视图。AWS Lambda 使用与 Amazon EC2 相同的技术在基础设施和执行级别上提供安全性和隔离。
  • 问:AWS Lambda 如何保护我的代码安全?
    • AWS Lambda 在 Amazon S3 中存储代码并在静态下加密代码。AWS Lambda 在使用您的代码时执行额外的完整性检查。

AWS Lambda 函数

  • 问:AWS Lambda 函数是什么?
    • 您在 AWS Lambda 上运行的代码以“Lambda 函数”上传。每个函数都有相关的配置信息,如其名称、描述、入口点和资源要求。代码必须以“无状态”样式编写,即应假设与底层计算基础设施无密切关系。本地文件系统访问、子过程和类似的项目可能不会超出请求的使用寿命,且任何持续状态都应存储在 Amazon S3、Amazon DynamoDB 或另一个可用 Internet 的存储服务中。Lambda 函数可包含库,甚至是本机库。
  • 问:AWS Lambda 是否会再使用函数实例?
    • 为了提高性能,AWS Lambda 可以选择保留您的函数实例,将其再用于服务后续请求,而不是创建一个新副本。您的代码不应假设此操作总是发生。
  • 问:如果我需要为我的 AWS Lambda 函数在磁盘上留下暂存空间会发生什么?
    • 每个 Lambda 函数都会在其自己的目录/tmp 目录中接收到 500MB 的非持久性磁盘空间。
  • 问:AWS Lambda 函数为什么必须是无状态的?
    • 保持函数的无状态性可使 AWS Lambda 按需要尽可能多地启动函数副本,从而扩展到传入事件的速率。由于 AWS Lambda 的编程模式是无状态的,因此您的代码可以通过调用其他 Web 服务,如 Amazon S3 或 Amazon DynamoDB,来访问有状态的数据。
  • 问:我能否在我的 AWS Lambda 函数代码中使用线程和进程?
    • 能。AWS Lambda 可使您使用正常的语言和操作系统功能,如创建额外的线程和进程。分配至 Lambda 函数的资源,包括内存、执行时间、磁盘和网络使用,都必须通过其使用的所有线程/进程进行共享。可以使用任意 Amazon Linux 支持的语言启动进程。
  • 问:哪些限制适用于 AWS Lambda 函数代码?
    • Lambda 尝试尽量不对正常的语言和操作系统活动施加限制,但有些活动仍被禁用:入站网络连接被 AWS Lambda 阻止;对于出站连接,只支持 TCP/IP 套接字;ptrace (调试) 系统调用受到限制。TCP 端口 25 流量同样受到限制,这是一项反垃圾邮件措施。
  • 问:如何使用 Lambda 控制台创建 AWS Lambda 函数?
    • 如果使用 Node.js 或 Python,您可以使用 AWS Lambda 控制台中的内联编辑器编写您的函数代码。前往控制台以开始操作。您也可以将代码 (以及任何依赖库) 打包为 ZIP 并使用 AWS Lambda 控制台从您的本地环境上传或指定 ZIP 文件所在的 Amazon S3 位置。上传的内容必须不超过 50MB (压缩后)。您可以使用 AWS Eclipse 插件以 Java 制作和部署 Lambda 函数。您可以使用 Visual Studio 插件以 C# 和 Node.js 制作和部署 Lambda 函数。
  • 问:如何使用 Lambda CLI 创建 AWS Lambda 函数?
    • 您可以将代码 (以及任何依赖库) 打包为 ZIP 并使用 AWS CLI 从您的本地环境上传或指定 ZIP 文件所在的 Amazon S3 位置。上传的内容必须不大于 50MB (压缩过的)。 请访问 Lambda 入门指南以开始。
  • 问:AWS Lambda 是否支持环境变量?
    • 支持。使用 AWS Lambda 控制台、命令行界面或软件开发工具包,即可轻松创建和修改环境变量。
  • 问:我能否在环境变量中存储敏感信息?
    • 对于敏感信息 (如数据库密码),我们建议您使用 AWS Key Management Service 进行客户端加密并将生成的值作为密文存储在您的环境变量中。您需要在 AWS Lambda 函数代码中包含逻辑才能解密这些值。
  • 问:如何管理我的 AWS Lambda 函数?
    • 您可以使用 AWS Lambda 控制台中的仪表板轻松列出、删除、更新和监控您的 Lambda 函数。您还可以使用 AWS CLI 和 AWS 软件开发工具包来管理您的 Lambda 函数。请访问 Lambda 开发人员指南了解更多信息。
  • 问:如何监控 AWS Lambda 函数?
    • AWS Lambda 会代您自动监控 Lambda 函数,从而通过 Amazon CloudWatch 实时报告指标,包括请求总数、延迟、出错率和节流请求。通过 Amazon CloudWatch 控制台或 AWS Lambda 控制台,可以查看每一个 Lambda 函数的统计信息。您还可以在您的 Lambda 函数中调用第三方监控 API。
  • 问:如何对 AWS Lambda 函数的故障进行故障排除?
    • AWS Lambda 与 Amazon CloudWatch 日志自动集成,对每个 Lambda 函数创建一个日志组并提供基本的应用程序生命周期事件日志条目,包括记录该函数每次使用时所消耗的资源。您可以轻松将额外的日志语句插入到代码中。您还可以在您的 Lambda 函数中调用第三方记录 API。
  • 问:如何扩展 AWS Lambda 函数?
    • 您不必扩展您的 Lambda 函数,AWS Lambda 会代您自动扩展它们。每当接收到您的函数的事件通知时,AWS Lambda 会在其计算舰队中快速定位空闲容量并运行您的代码。由于您的代码是无状态的,AWS Lambda 可以在需要时尽可能多地启动实例副本,而不会发生冗长的部署和配置延迟。函数的扩展方面没有基本限制。AWS Lambda 将动态分配容量以匹配传入事件的速率。
  • 问:如何将计算资源分配至 AWS Lambda 函数?
    • 在 AWS Lambda 资源模型中,您可以选择您想为函数分配的内存量,并按 CPU 功率和其他资源的比例进行分配。例如,选择 256MB 的内存分配至您的 Lambda 函数的 CPU 功率约是请求 128MB 内存的两倍,若选择 512MB 的内存,其分配的 CPU 功率约是一半。您可以在 128MB 到 1.5GB 的范围间以 64MB 的增量设置您的内存。
  • 问:AWS Lambda 函数的执行需要多长时间?
    • 对 AWS Lambda 进行的同步调用必须在 300 秒钟内执行完毕。默认的超时为 3 秒,但您可以将超时设置在 1 到 300 秒之间的任何值。
  • 问:使用 AWS Lambda 函数时我将如何付费?
    • AWS Lambda 按使用量收费。
  • 问:AWS Lambda 是否支持版本控制?
    • 是。默认情况下,每个 AWS Lambda 函数拥有单一的当前版本的代码。 Lambda 函数客户端可调用特定的版本或获取*新的实现。请阅读有关 Lambda 函数版本控制的文档。
  • 问:上传我的代码后,AWS Lambda 函数需要准备多久进行调用?
    • 部署时间根据代码大小的不同而不同,但 AWS Lambda 函数一般在上传后几秒钟内就能做好调用准备。
  • 问:我能否使用自己的支持的库版本?
    • 可以。您可以在其中包含自己的代码库的副本 (包括 AWS 软件开发工具包),以使用除 AWS Lambda 所提供的默认版本之外的版本。

使用 AWS Lambda 处理 AWS 事件

  • 问:什么是事件源?
    • 事件源是 AWS 服务或开发人员创建的应用程序,用于生成可触发 AWS Lambda 函数使其运行的事件。有些服务通过直接调用云函数 (例如 Amazon S3) 向 Lambda 发布这些事件。Lambda 也可以在未向 Lambda 发布事件的其他服务中轮询资源。例如,Lambda 可以从 Kinesis 数据流中拉取记录并为数据流中的每条消息执行 Lambda 函数。
    • 通过登录到 Amazon S3 并使用 S3 存储桶通知,就可将 AWS CloudTrail 等其他很多服务简单地用作触发 AWS Lambda 函数的事件源。
  • 问:如何在 AWS Lambda 中表示事件?
    • 事件作为事件输入参数的形式传输到 Lambda 函数中。对于事件以批量方式到达的事件来源,例如 Amazon Kinesis 和 Amazon DynamoDB 流,事件参数可以在一个调用中包含多个事件,具体取决于请求的批量处理的大小。关于 Amazon S3 事件通知的更多信息,请访问配置 Amazon S3 事件通知。关于 Amazon DynamoDB 流的更多信息,请访问 DynamoDB 流开发人员指南。关于使用 Amazon SNS 调用 Lambda 函数的更多信息,请访问 Amazon SNS 开发人员指南。关于 Amazon Cognito 事件的更多信息,请访问 Amazon Cognito。关于 AWS CloudTrail 日志和跨 AWS 服务审核 API 调用的更多信息,请参见 AWS CloudTrail。
  • 问:我如何对 Amazon S3 存储桶中的更改作出 AWS Lambda 函数响应?
    • 您可以从 AWS Lambda 控制台中选择一个函数并将其与 Amazon S3 存储桶中的通知关联起来。或者,您可以使用 Amazon S3 控制台并配置存储桶的通知以发送到您的 AWS Lambda 函数。还可通过 AWS 软件开发工具包和 CLI 实现这一功能。
  • 问:我如何对 Amazon DynamoDB 表中的更新作出 AWS Lambda 函数响应?
    • 通过将 Lambda 函数订阅到与 DynamoDB 表格相关联的 DynamoDB 流,您可以对 DynamoDB 表格更新触发 Lambda 函数。您可以使用 Amazon DynamoDB 控制台、AWS Lambda 控制台或 Lambda 的 registerEventSource API 将 DynamoDB 流与 Lambda 函数关联起来。
  • 问:如何使用 AWS Lambda 函数处理 Amazon Kinesis 流中的记录?
    • 您可以从 AWS Lambda 控制台中选择一个 Lambda 函数并将其与属于相同账户的 Amazon Kinesis 流进行关联。还可通过 AWS 软件开发工具包和 CLI 实现这一功能。
  • 问题:AWS Lambda 如何处理来自 Amazon Kinesis 流和 Amazon DynamoDB 流的数据?
    • 发送到您的 AWS Lambda 功能的 Amazon Kinesis 和 DynamoDB 流记录将根据分片进行严格序列化。这意味着,如果您将两个记录放在同一个分片中,则 Lambda 保证将首先通过*条记录来调用您的 Lambda 功能,然后再通过第二条记录来调用。如果*条记录的调用超时,或者遇到任何其他错误,则 Lambda 将重试直至其成功 (或者记录达到其 24 小时过期时间),然后才会对下一条记录采取操作。无法保证不同分片之间记录的排序,并且每个分片的处理是平行进行的。
  • 问:如何使用 AWS Lambda 函数响应 Amazon Simple Notification Service (SNS) 发出的通知?
    • 您可以从 AWS Lambda 控制台中选择一个 Lambda 函数并将其与 Amazon SNS 主题进行关联。还可通过 AWS 软件开发工具包和 CLI 实现这一功能。
  • 问:如何使用 AWS Lambda 函数响应 Amazon Simple Notification Service (SNS) 发出的通知?
    • 在 Amazon SES 控制台中,您可以设置接收规则,以使 Amazon SES 将消息交付到 AWS Lambda 函数。还可通过 AWS 软件开发工具包和 CLI 实现这一功能。
  • 问:如何使用 AWS Lambda 函数响应 Amazon CloudWatch 警报?
    • 首先应配置警报,使其发送 Amazon SNS 通知。然后从 AWS Lambda 控制台中选择一个 Lambda 函数并将其与 Amazon SNS 主题进行关联。请参阅 Amazon CloudWatch 开发人员指南,了解设置 Amazon CloudWatch 警报的更多信息。
  • 问:如何使用 AWS Lambda 函数响应由 Amazon Cognito 管理的用户或设备数据的变更?
    • 您可以从 AWS Lambda 控制台中选择一个函数,当与 Amazon Cognito 身份池关联的任何数据集进行同步时,触发这个函数。还可通过 AWS 软件开发工具包和 CLI 实现这一功能。请访问 Amazon Cognito,了解关于使用 Amazon Cognito 在用户设备中共享和同步数据的详细信息。
  • 问:应用程序如何直接触发 AWS Lambda 函数?
    • 您可以通过 AWS Lambda 的调用 API 使用自定义事件调用 Lambda 函数。只有该函数的所有者或获得该所有者收取的另一个 AWS 账户才能调用该函数。
  • 问:调用 AWS Lambda 函数响应事件的延迟如何?

AWS Lambda 的设计可在若干毫秒内处理事件。当 Lambda 函数创建、更新后,或如果它*近未被使用,延迟都将立即升高。

  • 问:我如何使用 AWS Lambda 创建移动后端?
    • 您上传需要 AWS Lambda 执行的代码,然后使用 AWS 移动软件开发工具包中的 AWS Lambda 软件开发工具包从移动应用程序中对其进行调用。您可以进行直接 (同步) 调用来检索或实时查看数据,也可以进行异步调用。您也可以使用 Amazon API Gateway 定义自定义 API,并通过兼容 REST 的任何客户端调用您的 Lambda 函数。要详细了解 AWS 移动软件开发工具包,请访问 AWS Mobile SDK 页面。要详细了解 Amazon API Gateway,请访问 Amazon API Gateway 页面。
  • 问:如何通过 HTTPS 调用 AWS Lambda 函数?
    • 通过使用 Amazon API Gateway 定义自定义的 RESTful API,您可以通过 HTTPS 调用 Lambda 函数。这为您的函数提供了端点,这些函数可以响应 GET、PUT 和 POST 等 REST 调用。了解有关通过 Amazon API Gateway 使用 AWS Lambda 的更多信息
  • 问:AWS Lambda 函数如何根据发起请求的设备和应用程序对其行为进行自定义?
    • 当通过 AWS 移动软件开发工具包进行调用时,AWS Lambda 函数能自动通过“context”对象获得发起调用的设备和应用程序的深入洞见。
  • 问:AWS Lambda 函数如何根据应用程序终端用户的身份对其行为进行个性化?
    • 当应用程序使用 Amazon Cognito 身份时,终端用户可以使用各种公共登录供应商 (包括 Amazon、Facebook、Google) 及其他 OpenID Connect 兼容服务来对其进行验证。之后用户身份会自动加密并以 Amazon Cognito id 的形式呈送给 Lambda 函数,同时允许其访问 Amazon Cognito 中的用户数据,或作为密钥储存和检索 Amazon DynamoDB 或其他 web 服务中的数据。
  • 问:如何使用 AWS Lambda 创建 Alexa 技能?
    • AWS Lambda 与 Alexa 技能套件集成,后者是一个自助 API、工具、文档和代码示例集合,让您能够为 Alexa 轻松创建以语音为主的能力 (或“技能”)。您只需为新的 Alexa 技能上传 Lambda 函数代码,AWS Lambda 将完成剩余工作,包括执行代码以响应 Alexa 语音交互,并代表您自动管理计算资源。有关更多详细信息,请阅读 Alexa 技能套件文档。
  • 问:如果我的函数在处理事件时发生故障会发生什么?
    • 对于 Amazon S3 存储桶通知和自定义事件,AWS Lambda 将在您的代码发生错误条件或您超出服务或资源限制时尝试执行您的函数三次。对于 AWS Lambda 代您轮询的有序事件源,如 Amazon DynamoDB Streams 和 Amazon Kinesis 数据流,Lambda 将在发生开发人员代码错误时继续尝试执行,直到该数据过期为止。您可以通过 Amazon Kinesis 和 Amazon DynamoDB 控制台以及 AWS Lambda 为您的函数生成的 Amazon CloudWatch 指标监控进展情况。您还可以根据出错率或执行节流的频率来设置 Amazon CloudWatch 警报。

使用 AWS Lambda 构建应用程序

  • 问:什么是无服务器应用程序?
    • 基于 Lambda 的应用程序 (也被称作无服务器应用程序) 由通过事件触发的函数组成。典型的无服务器应用程序包含一个或多个通过事件 (如向 Amazon S3 上传对象、Amazon SNS 通知或 API 操作) 触发的函数。这些函数既可独立运行,也能利用其他资源 (如 DynamoDB 表或 Amazon S3 存储桶)。*基本的无服务器应用程序仅包含一个函数。
  • 问:如何部署和管理无服务器应用程序?
    • 您可以使用 AWS 无服务器应用程序模型 (AWS SAM) 部署和管理无服务器应用程序。AWS SAM 是一项规范,其中规定了在 AWS 上表达无服务器应用程序的规则。该规范当前与 AWS CloudFormation 使用的语法相同,因此本身在 AWS CloudFormation 中作为一组资源类型 (被称作“无服务器资源”) 就受支持。得力于这些资源,AWS 客户能够更轻松地使用 CloudFormation 通过现有 CloudFormation API 配置和部署无服务器应用程序。
  • 问:如何自动部署无服务器应用程序?
    • 您可以使用 CodePipeline 自动执行无服务器应用程序的发布过程。CodePipeline 是一项持续交付服务,借助该服务,您能够为发布应用程序所需的步骤构建模型、使之可视化并自动执行这些步骤。
  • 问:如何开始构建无服务器应用程序?
    • 首先,请访问 AWS Lambda 控制台,并下载我们的蓝图之一。您下载的文件将包含一份 AWS SAM 文件 (定义了您应用程序中的 AWS 资源) 和一份 .ZIP 文件 (包含您函数的代码)。然后,您可以使用 AWS CloudFormation 命令打包和部署您刚下载的无服务器应用程序。
  • 问:如何协调多个 AWS Lambda 函数之间的调用?
    • 您可以使用 AWS Step Functions 以特定顺序来协调一系列 AWS Lambda 函数。您可以按顺序调用多个 Lambda 函数,然后将一个函数的输出传递到另一个函数,也可以进行并行调用,Step Functions 将在执行期间为您保持状态。
  • 问:怎样排除无服务器应用程序的故障?
    • 您可以启用 Lambda 函数利用 AWS X-Ray 进行跟踪的功能,方式为将 X-Ray 的权限添加到 Lambda 函数的执行角色,然后将函数的“跟踪模式”更改为“激活”。针对 Lambda 函数启用 X-Ray 之后,AWS Lambda 会将调用函数产生的 Lambda 服务开销方面的跟踪信息发送到 X-Ray。这样,您就能了解 Lambda 服务开销、函数启动时间和函数执行时间等信息。此外,您还可以将 X-Ray SDK 纳入 Lambda 部署程序包中,以便创建自己的跟踪段、为跟踪添加注释或者查看从 Lambda 函数进行的下游调用的跟踪段。X-Ray SDK 目前支持 Node.js 和 Java。请查看排除基于 Lambda 的应用程序的故障以便了解更多。我们会按 AWS X-Ray 的费率收取费用。
  • 问:AWS SAM 如何获得许可证?
    • 该规范在 Apache 2.0 下是开源性质的,允许您及他人采用构建、部署、监控和管理工具以及通过商业版许可证将 AWS SAM 融合到这些工具中。您可以在此处访问 GitHub 上的 AWS SAM 存储库。

扩展性和可用性

  • 问:AWS Lambda 函数的可用性如何?
    • AWS Lambda 旨在通过复制和冗余来向服务本身和其操作的 Lambda 函数提供高可用性。二者皆无维护窗口期或计划停机时间。
  • 问:当我改动代码或配置时,AWS Lambda 函数还可以使用吗?
    • 可以。当您更新 Lambda 函数时,会有短暂的窗口期,通常不到 1 分钟,在这期间请求将由旧版本函数或新版本函数实现。
  • 问:对于一次可以执行的 AWS Lambda 函数的数量有没有限制?
  • 没有。AWS Lambda 采用的设计可以支持大量函数实例并列运行。但是,AWS Lambda 对每个区域的每个账户的并发执行次数具有默认安全限制(请访问此处了解默认安全限制数量的信息)。如果您想申请提高可访问我们支持中心的限制数量,请单击“Open a new case”,然后发出服务限制提升请求。
  • 问:如果账户超出并发执行绪默认限制数量会怎样?
    • 如果超出限制,同步调用的 AWS Lambda 函数会返回一条节流错误信息 (429 错误代码)。异步调用的 Lambda 函数可以承受一定范围内的流量突增大约 15 到 30 分钟,之后再进来的事件将会以节流为理由遭到拒*。如果调用的 Lambda 函数是用于响应 Amazon S3 事件,则被 AWS Lambda 拒*的事件可能被 S3 保留 24 小时并在此期间反复重试。Amazon Kinesis 流和 Amazon DynamoDB 流中的事件会反复重试,直到 Lambda 函数成功或数据过期。Amazon Kinesis 和 Amazon DynamoDB 流会将数据保留 24 小时。
  • 问:默认的数量限制是否在个别函数级别应用?
    • 不是,默认的数量限制只在账户级别应用。
  • 问:如果 Lambda 函数在处理事件时发生故障会怎样?
    • 如遇故障,进行同步调用的 Lambda 函数会返回异常信息。异步调用的 Lambda 函数将至少重试 3 次。Amazon Kinesis Streams 和 Amazon DynamoDB Streams 中的事件会反复重试,直到 Lambda 函数成功或数据过期。Kinesis Streams 和 DynamoDB Streams 会至少保留数据 24 个小时。
  • 问:如果 Lambda 函数调用用尽了策略规定的次数,会怎样?
    • 当超过策略针对异步调用规定的重试次数时,您可以配置一个放置此事件的“死信队列”(DLQ);如果尚未配置 DLQ,此事件可能会被拒*。当超过策略针对基于流的调用规定的重试次数时,数据可能已失效,因此已被拒*。
  • 问:我可以将哪些资源配置为 Lambda 函数的死信队列?
    • 您可以将 Amazon SQS 队列或 Amazon SNS 主题配置为您的死信队列。

安全性与访问控制

  • 问:如何允许我的 AWS Lambda 函数访问其他 AWS 资源?
    • 您可以使用 IAM 角色授予 Lambda 函数相应的权限,以访问其他资源。AWS Lambda 在执行您的 Lambda 函数的同时承担该角色,因此您可以对该服务可使用的 AWS 资源保持完整、安全的控制。请访问设置 AWS Lambda 以了解有关角色的更多信息。
  • 问:如何控制哪些 Amazon S3 存储桶可以调用哪些 AWS Lambda 函数?
    • 当您配置 Amazon S3 存储桶向 AWS Lambda 函数发送消息时,将创建一条资源政策规则用于权限授予。请访问 Lambda 开发人员指南,了解 Lambda 函数的资源政策和访问控制的详细情况。
  • 问:如何控制 AWS Lambda 函数可以轮询的 Amazon DynamoDB 表或 Amazon Kinesis 数据流?
    • 对访问控制的管理通过 Lambda 函数的角色实现。分配给 Lambda 函数的角色同时决定了 AWS Lambda 可以代表其进行轮询的资源。
  • 问:我是否可以使用 AWS Lambda 函数访问 Amazon VPC 后端的资源?
    • 可以。您可以访问 Amazon VPC 后端的资源。
  • 问:如何启用和禁用针对 Lambda 函数的 VPC 支持?
    • 要启用 VPC 支持,您需要在单个 VPC 中指定一个或多个子网,并在配置函数时指定安全组。要禁用 VPC 支持,您需要更新函数配置并为子网和安全组指定空列表。您可以使用 AWS API、CLI 或 AWS Lambda 管理控制台更改这些设置。
  • 问:一个 Lambda 函数是否可以访问多个 VPC?
    • 不可以。Lambda 函数只能访问一个 VPC。如果指定多个子网,则所有子网都必须位于同一个 VPC 中。您可以通过在 VPC 之间建立对等连接来连接到其他 VPC。
  • 问:一个 VPC 中的 Lambda 函数是否还能够访问 Internet 和 AWS 服务端点?
    • 在默认配置下,配置为可访问特定 VPC 中资源的 Lambda 函数将无法访问 Internet。如果您需要访问外部端点,则需要在 VPC 中创建 NAT,以转发相应流量并将安全组配置为允许这些出站流量。

使用 Java 的 AWS Lambda 函数

  • 问:我如何使用 Java 代码编译我的 AWS Lambda 函数?
    • 您可以使用 Maven 或 Gradle 等标准工具编译 Lambda 函数。您的构建过程应模拟编译任何 Java 代码的同一构建过程,这取决于 AWS SDK。在源文件上运行您的 Java 编译器工具并在类路径上包含 AWS SDK 1.9 或更高版本,以延续依赖性。有关详细信息,请参阅我们的文档。
  • 问:用于执行函数的 JVM 环境 Lambda 是什么?
    • Lambda 提供 openjdk 1.8 的 Amazon Linux 版本。

  • 问:我能否更改 Amazon Linux 或任何语言运行时的版本?
    • 不能。AWS Lambda 向该服务的所有用户提供单一版本的操作系统和语言运行时。
  • 问:如何记录和审核对 AWS Lambda API 进行的调用?
    • AWS Lambda 与 AWS CloudTrail 集成。AWS CloudTrail 可以记录日志文件并将其提供给 Amazon S3 存储桶,用于说明账户的 API 使用情况。
  • 问:我如何协调多个 Lambda 函数之间的调用?
    • 您可以使用 Amazon Step Functions 来协调多个 Lambda 函数之间的调用。您可以按顺序调用多个 Lambda 函数,然后将一个函数的输出传递到另一个函数,