2Flask与Http

Flask（瓶子，烧瓶）是使用Python编写的Web为框架，

Web框架可以让我们不用关心底层的请求相应处理，更方便高效地编写Web程序。

因为Flask核心是：简单且已于扩展，所以被称作为框架。
Flask有2个主要依赖：
* 一个是WSGI（Web Segver Gateway Inteface，Web服务器网关接口）工具集——Werkzeug。
* 另一个是Jinjia2模板引擎
> WSGI是Python中用来规定Web服务器如何与PythonWeb程序进行沟通的标准。




### 1.1搭建开发环境
#### 1.1.1 pipenv 工作流
pipenv是基于pip的python包管理工具，

它和pip的用法非常相似，可以看作pip的加强版，它的出现解决了旧的pip+virtualenv+requirement.txt的工作方式的弊端。

具体来说，它是pip、pipfile和virutalenv的结合体，它让包安装、包依赖管理和虚拟环境管理更加方便，使用它可以实现更高效的python项目开发工作流。

使用pip安装pipenv
```
pip install pipenv
```
##### 1.创建虚拟环境
使用pipenv install 命令为当前的项目创建虚拟环境。

如果项目根目录下没有Pipfile文件，就会创建Pipfile和Pipfile.lock文件，

前者用来记录项目依赖包列表，后者记录了固定版本的详细依赖包列表。

当我们使用Pipenv安装/删除/更新依赖包时，Pipfile和Pipfile.lock会自动更新：
```
pipenv nstall
```
>这会为当前项目创建一个文件夹，其中包含隔离的Python解释器环境，并且安装pip、wheel、setuptools等基本的包。
>
>默认情况下，Pipenv会同意管理所有虚拟环境，
>
>在Windows系统中，虚拟环境文件夹会在C:\Users\Administrator\.virtualenvs\目录下创建，
>
>而Linux或MacOS会在~/.local/share/virtualenvs/目录下创建。
>
>如果你想在项目目录内创建虚拟环境文件夹，可以设置环境变量PIPENV_VENV_IN_PROJECT,
>
>这时名为.vev的虚拟环境文件夹将在项目根目录创建。
```
export PIPENV_VENV_IN_PROJECT=1
```
>可以通过--three和--two选项来声明虚拟环境中使用的Python版本，或是使用--python选项指定具体的版本号。

在Pipenv中，可以使用pipenv shell命令显示地激活虚拟环境。退出使用exit：

```
pipenv shell
```
当执行pipenv shell 或pipenv run命令时，pipenv会自动从项目目录下的.env文件中加载环境变量。

除了显示地激活虚拟环境，pipenv还提供了一个pipenv run命令，这个命令允许你不显示地激活虚拟环境即可在当前项目的虚拟环境中执行命令，比如：
```
pipenv run python hello.py
```
##### 2.创建程序实例
```
from flask import Flask
app= FLask(__name__)
```
##### 3.注册路由
```
@app.route('/greet',defaults={'name':'Product'})   # 默认值
@app .route (’ / hi/<name> ' )  # 动态url
@app . route ( ' / hello ’)
def say hello () :
    return hl>Hello  Flask ' </hl> '
```
### 1.2启动开发服务器
```
flask run
```
#### 1.自动发现程序实例
一般来说，在执行flask run命令运行程序前，我们需要提供程序实例所在模块的位置。

我们在上面可以直接运行程序，是因为Flask会自动探测程序实例，自动探测存在下面这些规则：

* 从当前目录寻找app.py和wsgi.py模块，并从中寻找名为app或application的程序实例。
* 从环境变量Flask_APP对应的值寻找名为app或application的程序实例。

因为我们的程序主模块命名为app.py，所以flask run命令会自动在其中寻找程序实例。

如果你的程序主模块是其他名称，比如hello.py，

那么需要设置变量FlASK_APP，将包含程序实例的模块名赋值给这个变量。

Linux或macOS使用export命令：
```
export FLASK_APP = hello
```
在windows系统中使用set命令：
```
set FLASK_APP =hello
```
#### 2.管理环境变量
Flask的自动发现程序实例机制还有第三条规则：如果安装了pythonn-dotenv，

那么在使用flask run或其他命令时会是使用它自动从.flaskenv文件和.env文件中加载环境变量。

>当安装了python-dotenv时，Flask在加载环境变量的优先级是：
>
>手动设置的环境变量>.env中设置的环境变量>.flaskenv设置的环境变量

我们在项目根目录下分别创建两个文件：.env和.flaskenv。

.flaskenv用来存储和Flask相关的公开环境变量，比如FLASK_APP；

而.env用来存储包含敏感信息的环境便令，比如我们会用来配置Email服务器的账户名和密码。

在.flaskenv或.env文件中，环境变量使用键值对的形式定义，每行一个，以#开头的为注释，如下所示：
```
SOME_VAR=1
# 这是注释
FOO="BAR"
```
#### 3.设置运行环境
开发环境和生产环境是我们后面会频繁接触到的概念。

开发环境是指我们在本地编写和测试程序时的计算机环境，而生产环境与开发环境相对，它指的是网站部署上线用户访问的服务器环境。

根据运行环境的不同，Flask程序、扩展以及其他程序会改变相应的行为和设置。
我们将把环境变量FLASK_ENV的值写入.flaskenv文件中。
```
FLASK_ENV=development
```
>如果你想单独控制调试模式的开关，可以通过FLASK_DEBUG环境变量设置，设为1，则开启，设为0，则关闭。不过通常不推荐手动设置这个值。

**重载器**

默认会使用Werkzeug内置的stat重载器，它的缺点是耗电较验证，而且准确性一般。

为了获得更优秀的体验，我们可以安装另一个用于监测文件变动的Python库Watchdog，安装后Werkzeug会自动使用它来监测文件变动：

```
pipenv install watchdog --dev
```
因为这个包只在开发时才会用到，所以我们在安装命令后添加了一个 --dev选项，这用来把这个包声明为开发依赖。

在Pipefile文件中，这个包会被添加到dev-packages部分。

不过，如果项目中使用了单独的css或JS文件时候，那么浏览器可能会缓存这些文件，从而导致对文件做出的修改不能立刻生效。

在浏览器中，我们可以按下Crtl+F5执行硬重载，即忽略缓存并重载（刷新）页面。

### 1.3 Flask扩展

以某扩展实现了 Foo 功能为例，这个扩展的名称将是 Flask Foo Foo-Flask ；

程序包或模块的命名使用小写加下划线，即 flask foo 即导人时的名称 ；

用于初始化的类一般为 Foo ，实例化的类实 般使用小 ，即 foo 初始化这个假想中的 ask Foo 扩展的示例如下所示：
```
from flask import Flask
from flask_foo impor Foo
app =Flask( __name__ )
foo =Foo (app)
```
### 1.4 项目配置
在一个项目中，你会用到许多配置：
* Flask提供的配置
* 扩展提供的配置
* 程序特定的配置。

和平时使用变量不同，这些配置变量都通过Flask对象的app.config属性作为统一的接口来设置和获取，它指向的Config类实际上是字典的子类，所以你可以像操作其他字典一样操作它。

```
app.config['ADMIN_NAME']= 'Peter'
```
使用update()方法则可以一次加载多个值：
```
app.config.update(
TESTTING=True,SECRET_KEY='_sadkowpqk_'
)
```
### 1.5 URL与端点
为了解决修改路由的问题，使用FLask提供的url_for()函数获取url，当路由中定义的URL规则被修改时候，这个函数总会返回争取的URL。
```
@app .route (’ / ’ )
def index() :
    return ’ Hello Flask l ’
调用url_for（'index'）即可获取对应的URL，即'/'
```
### 1.6 Flask命令
通过创建任意一个函数，并为其添加app.cli.command()装饰器，我们就可以注册一个flask命令。
```
@app.cli.command()
def hello():
    click.echo(’hello ,Human‘)
```
在命令行下执行flask hello 就会出发这个hello()函数:
```
$flask hello
hello,Human
```
### 1.7 模板与静态文件
默认情况下，模板文件存放在项目根目录中的templates文件中，静态文件放在static文件下。

这两个文件需要和包含程序实例的模块处于同一个目录下，对应的项目结构示例如下所示：
>hello/
>   templates/
>   static/
>   app.py

### 1.8 Flask与MVC架构

![image.png](https://www.choumaomi.com/static/img/68a591d04630ab82a8cfde6375d2ef07.image.png)
术语views用来表示MVC（Model-View-Controller,模型-视图-控制器）架构中的View。

在MVC架构中，程序被分为三个组件：数据处理(Model)、用户界面（view）、交互逻辑（controller）。

严格来说，Flask并不是MVC架构的框架，因为它没有内置数据模型支持。

为了方便描述，使用了app.route()装饰器的函数仍被称为书体函数，同时会使用<函数名>视图的形式来代指某个视图函数。

粗略归类，如果想要使用Flask编写一个MVC架构的程序，那么视图函数可以作为控制器，视图则是使用Jinja2渲染的HTML模板，而模型Model可以使用其他库来实现。

1Flask起步

### 1. 版本检查
```
import sqlalchemy
sqlalchemy.__version__
```

### 2. 链接
echo：True   会显示每条执行的SQL语句，可以关闭。
create_engine()返回一个Engine的实例，并且它表示通过数据库语法处理细节的核心接口
```
from sqlalchemy import create_engine
engine = create_engine('sqlite:///:memory',echo=True)
```

### 3.声明映像
当使用orm时，构造进程首先描述数据库的表，然后定义我们用来映射哪些表的类。
在现版本中，这2个任务通常一起执行，通过使用Declarative方法，我们可以创建一些包含描述要被映射的实际数据库表的准则的映射类。
通过delarative_base()创建一个基类：
```
from sqlalchemy.ext.declarative import declarative_base
Base=declarative_base()
# 依据这个base定义任意数量的映射类
from sqlalchemy import Column,Integer,String
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer,primary_key=True)
    name = Column(String)
```
### 4.构造模式（暂无）
### 5.创建映射类的实例
```
ed_user = User(name='ed',fullname='Ed Jones',password='edpassword')
```
### 6. 创建会话
orm通过Session与数据库建立链接的，当应用第一次载入时，我们定义一个Session类(声明create_engine（）的同时)，这个session类为新的session对象提供工厂服务。
```
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
```
这个定制的session类会创建绑定到数据库的session对象。如果需要和数据库建立链接，只需要实例化一个session：
```
session = Session()
```
此时对象的实例仍在等待中，只有在被使用的时候，才会建立链接。

### 7.添加新对象
```
ed_user = User(name='ed',fullname='Ed Jones',passoword='edspassword')
session.add(ed_user)
session.commit()  # 提交所有剩余的更改数据库
```
### 8.回滚
```
session.rollback()
```
### 9. 查询
通过session的query()方法创建一个查询对象。这个函数的参数数量是可变的，参数可以是任何类或者是类的描述的集合。
```
for instance in session.query(User).order_by(User.id)
    print instance.name,instance.fullname
```
或者
```
for name,fullname in session.query(User.name,User.fullname):
    print name,fullname
```
label()相当于row.name
```
for row in session.query(User.name.label('name_label')).all():
    print(row.name_label)
```
aliased()，是类的别名，如果有多个实体都要查询一个类，可以用aliased()
```
for sqlalchemy.orm import aliased
    user_alias = aliased(User,name='user_alias')
for row in session.query(user_alias,user_alias.name).all():
    print row.user_alias
```
Query的Limit和Offset操作：
```
for u in session.query(User).order_by(User.id)[1:3]:
    print u
```
#### 9.1 关键字过滤查询

* query.filter(User.name == 'ed')  # 等于
* query.filter(User.name != 'ed')   # 不等于
* query.filter(User.name.like('%ed%'))  # 模糊查询
* user.filter(User.name.in_(['ed','wendy','jack']))  # in
* query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))  # in
* query.filter(~User.name.in_(['ed','wendy','jack']))  # not in
* query.filter(User.name ==None)  #is None
* query.filter(User.name !=None)  # not None
**与的操作**
```
from sqlalchemy import and_
```
* query.filter(and_(User.name == 'ed',User.fullname =='Ed Jones')) # and
* query.filter(User.name =='ed',User.fullname =='Ed Jones')  ＃and
* query.filter(User.name == 'ed').filter(User.fullname == 'Ed Jones' ) # and

**并的操作**
```
from sqlalchemy import or_
```
* query.filter(or_(User.name =='ed',User.name =='wendy'))  # or
* query.filter(User.name.match('Wendy'))  #match

#### 9.2 返回列表和数量

1. all()返回一个列表：可以进行Python列表的操作
```
query = session.query(User).filter(User.name.like('%ed')).order_by(User.id)
query.all()
输出
[<User(name='ed',fullname='EdJones', password='f8s7ccs')>,<User(name='fred',fullname='FredFlinstone', password='blah')>]
```
2. first() 适用于限制一个情况，返回查询到的第一个结果作为标量？
```
query.first()

<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>
```
3. one()完全获取所有行，并且如果查询到的不只有一个对象或是复合行，就会抛出异常。
```
from sqlalchemy.orm.exc import MultipleResultsFound
user=query.one()
try:
    user = query.one()
except:
    MultipleResultsFound, e:
    print e
```
如果一行也没有，会抛出no row was found的错误。
**scalar()作为one()方法的一句，并且在one()成功基础上返回行的第一列**
```
query = session.query(User.id).filter(User.name =='ed')
query.scarlar()
```
#### 9.3 使用字符串SQL

#### 9.4 计数
 count()用来统计查询结果的数量 
```
session.query(User).filter(User.name.like('%ed')).count()
```
更高级的用法：func.count()
```
from sqlalchemy import func
session.query(func.count(User.name),username).group_by(User.name).all()
[(1,'ed'),(1,'fred'),(1,'mary'),(1,'wendy')]
```
为了实现简单技术SELECT count(\*) FROM table:
```
session.query(func.count('*')).select_from(User).scalar()
或者
session.query(func.count(User.id)).scalar()
```
### 10. 建立联系（外键）
```
class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)
    name = Column(String)

    addresses = relationship("Address", backref="user")


class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    email = Column(String)
    user_id = Column(Integer, ForeignKey('user.id'))
```

#### **具体解释：**
1、假如没有relationship，我们只能像下面这样调用关系数据。
#给定参数user.name，获取该user的addresses（从一个表查询完了之后，再去另一个表中查找）
```
def get_addresses_from_user(user_name):
    user=session.query(User).filter_by(name=user_name).first()
    address=session.query(Address).filter_by(user_id=user.id).first()
    return address
```
如果在User中使用relationship定义addresses属性的话，
```
addresses=relationship('Address')
```
则我们直接在User对象中通过addresses属性获得指定用户的所有地址
```
def get_addresses_from_user(user_name):
    user=session.query(User).filter_by(name=user_name).first()
    return user.addresses
```
**注意，在上面的addresses属性中，我们并没有定义backref属性，所以我们可以通过User对象获取所拥有的地址，但是不能通过Address对象获取到所属的用户**
```
>>> u = User()
>>> u.addresses
[]
>>> a = Address()
>>> a.user
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'Address' object has no attribute 'user'
```
但是当我们有从Address对象获取所属用户的需求时，backref参数就派上用场了。
```
addresses = relationship('Address', backref='user')
```
>简而言之
**backref用于在关系另一端的类中快捷地创建一个指向当前类对象的属性**


**概念性的东西**
>在大多数的外键约束关系数据库只能连接到一个主键列，或具有唯一约束的列。
>外键约束如果是指向多个列的主键，并且它本身也具有多列，这种被称为：“复合外键”
>外键可以自动更新自己来相应它所引用的行或者列。这被称为级联，是一种建立在关系数据库的功能。
>外键可以参考自己的表格。这种被称为“自引”外键

#### backref 和 back_populates的区别
[brackref和back_populates的区别](https://blog.csdn.net/sinat_41667855/article/details/118729091?spm=1001.2014.3001.5501)
放代码：
```
class Comment(db.Model):    
    id = db.Column(db.Integer, primary_key=True)    
    author = db.Column(db.String(30))    
    email = db.Column(db.String(254))    
    site = db.Column(db.String(255))    
    body = db.Column(db.Text)    
    from_admin = db.Column(db.Boolean, default=False)    
    reviewed = db.Column(db.Boolean, default=False)    
    timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)    
    replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))    
    post_id = db.Column(db.Integer, db.ForeignKey('post.id'))    
    post = db.relationship('Post', back_populates='comments')    
    replies = db.relationship('Comment', back_populates='replied', cascade='all')    
    replied = db.relationship('Comment', back_populates='replies', remote_side=[id])

```
> cascade的属性

* cascade=save-update; 默认选项，在添加一条数据的时候，会把其他和它相关联的数据都添加到数据中。若不想同步添加，令cascade=''
* delete；表示当删除某一个模型中的数据的时候，是否也删掉使用relationship和他相关的数据。
* delete-orphan：表示当对一个ORM对象接触了父表中的关联对象的时候，自己便会被删除掉。（即子表中的某条数据没有了关联数据，则该条数据会被自动删除掉）。当然如果父表中的数据被删除，自己也会被删除。这个选项只能用在一对多上，不能用在多对多以及多对一上。并且还需要在子模型中relationship中，增加一个single_parent=True的参数。
* merge：默认选项，当在使用session.merge，合并一个对象的时候，会将使用了relationship相关联的对象也进行merge操作。如user表中已有一条数据id=1,而脚本中另外生成了一条id=1的数据。那么就可用merge覆盖掉原数据及相关联数据。
* all：是对 save-update、merge、refresh-expire,expunge,delete几种的缩写。

> remote_side
* remote_side 字段用于建立多对一的关系，如果不加这个字段会报错。

### 11.操作主外键关联的对象
现在我们已经在User类中创建了一个空的addresser集合，可变集合类型，例如set和dict，都可以用，但是默认的集合类型是list。
```
>>>jack = User(name='jack',fullname='Jack Bean',passowrd ='gjffdd')
>>>jack.address
[]
```
现在可以直接在User对象中添加Address对象。只需要指定一个完整的列表：
```
jack.addresses = [Address(email_adress='jack@google.com'),Address('j25@yahoo.com')]
```
### 12.使用JOINS查询
现在有了2张表，可以进行更多的查询操作。
```
for u,a in session.query(User,Address).filter(User.id==Adress.user_id).filter(Address.email_address=='jack@google.com').all()
    print u
    print a
 
```
**用Query.join()方法会更加简单**
```
session.query(User).join(Address).filter(Adress.email_address=='jack@google.com').all()
```

之所以Query.join()知道怎么join两张表是因为他们之间只有一个外键。如果两张表中没有外键或一个以上的外键，当下列几种形式使用的时候，Query.join()可以表现的更好：
```
query.join(Address,User.id==Address.user_id)  # 明确的条件
query.join(User.addresses)  #指定从左到右的关系
query.join(Address,User.addresses)  # 同样，有明确的目标
query.join('addresses')  # 同样，使用字符串
query.outer_join(User.addresses)  # LEFT OUTER JOIN
```
#### 1.使用别名
当在多个表中查询时，如果同一张表需要被引用好几次，SQL通常要求对这个表起一个别名，因此，SQL可以区分这个表进行的其他操作。Query也支持别名的操作。下面我们joinAddress实体两次，找到同时拥有2个不同的email的用户。
```
>>> from sqlalchemy.orm import aliased
>>>adalias1 = aliased(Address)
>>>adalias2 = aliaed(Address)
>>> for username,email1,email2 in 
      session.query(User.name,adalias1.email_address,adalias2.email_address).
      join(adalias1,User.addresses).
      join(adalias2,User.addresses).
      filter(adalias1.email_address =='jack@google.com').
      filter(adalias2.email_address == 'j25@yahoo.com'):
      print username,email1
```

#### 2.使用子查询
```
from sqlalchemy.sql import func
stmt = session.query(Address.user_id.func.count('*').
          label('address_count')).group_by(Address.user_id).subquery()
>>>
for u,count in session.query(User,stmt.c.address_count).outerjoin(stmt,User.id ==stmt.c.user_id).order_by(User.id)
    print u,count
```
#### 3.从子查询中选择实体
上面的代码中，我们只返回了包含子查询的一个列的结果。如果想要子查询映射到一个实体的话，使用aliaesd()设置一个要映射类的子查询别名。
```
stmt = session.query(Address).filter(Address.email_address!='j25@yahoo.com').subquery()
adalias = aliased(Address,stmt)
>>> for user,address in session.query(User,adalias).join(adalias,User.addresses):
    print user
    print address
```

#### 4.使用exists（存在？)
#### 5.常见的关系运算符
== != None 都是用在多对一中，而contains()用在一对多的集合中：
```
query.filter(Address.user ==someuser)
query.filtere(User.addresses.contains(someaddress))
```
**Any()用于集合中**
```
query.filter(User.addresses.any(Address.email_address =='bar'))
query.filter(User.addresses.any(email_address='bar'))
```
**as()用在标量？不在集合中**
```
query.filter(Address.user.has(name='ed'))
```
**query.with_parent() 所有关系都适用**
```
session.query(Address).with_parent(someuser,'addresses')
```

[更多Sqlalchemy的使用经验](SQLAlchemy使用经验.md)

SqlAlchemy的官方文档

MongoEngine官方文档

# centos 安装pgsql
> 注意：本环境是基于centos8，其他可能不适合，谨慎使用
# 一、安装流程
1. 列出可用的PostgreSQL模块流，请输入:
```shell
dnf module list postgresql
```
输出显示可用的postgresql.每个个都包含服务器喝客户端，postgresql10是默认设置。【可以通过stream数字后边如何包含d,就是默认设置】

2. 安装默选项的postgresql服务器版本10.0，直接如下安装命令:
```shell
sudo dnf install @postgresql:10
```
安装其他版本的，请输入:
```shell
sudo dnf install @postgresql:9.6
```
3. 你可能还需要安装contrib软件包，该软件包为postgreSQl数据库提供了一些附加的功能
```shell
sudo dnf install postgresql-contrib
```
4. 安装完成后，初始化PostgreSQL数据库:
```shell
sudo postgresql-setup initdb
```
输出
```shell
Initializing database ... OK
```
5. 启动PostgreSQL服务，并配置为其能够在系统启动时启动：
```shell
sudo systemctl enable --now postgresql
```
6. 验证是否安装成功，使用该psql工具通过连接到PostgreSQL数据库服务器来验证安装并打印其版本
```shell
sudo -u postgres psql -c "SELECT version();"
```
输出：
```shell
PostgreSQL 10.6 on x86_64-redhat-linux-gnu, compiled by gcc (GCC) 8.2.1 20180905 (Red Hat 8.2.1-3), 64-bit
```

# 二、角色和验证方法
PostgreSQL支持多种身份验证方法。最常用的方法是：

* 信任-只要符合定义的条件，角色就可以不使用密码进行连接pg_hba.conf。
* 密码-角色可以通过提供密码进行连接。密码可以存储为scram-sha-256，md5和password（明文）。
* 标识符-仅在TCP/IP连接上受支持。它通过获取客户端的操作系统用户名以及可选的用户名映射来工作。
* 对等-与Ident相同，但仅在本地连接上受支持。
访问配置文件路径:
```shell
/var/lib/pgsql/data/pg_hba.conf
```

PostgreSQL客户端身份验证在名为pg_hba.conf的配置文件中定义。默认情况下，对于本地连接，PostgreSQL设置为使用对等身份验证方法。

在你安装PostgreSQL服务器过程中postgres用户会被自动创建。该用户是PostgreSQL实例的超级用户，你可以看成等效于MySQL的root用户。

要以postgres用户身份登录到PostgreSQL服务器，需要首先切换到该用户，然后运行psql命令程序访问PostgreSQL提示符：

```shell
sudo su - postgres
psql
```
退出，输入q.
# 三、创建角色、数据库、设置密码
1. 进入到PostgreSQL shell
```shell
sudo -u postgres psql
```
2. 创建角色
```shell
create role john;
```
3. 创建数据库
```shell
create database johndb;
```
4. 将数据库授权用户：
```shell
grant all privileges on database johndb to john;
```
5. 给默认用户postsql添加密码
```shell
alter role postgres with password 'xiaosan121009';
```
6. 重启服务
```shell
sudo systemctl restart postgresql
或者
sudo systemctl reload postgresql
```

# 四、远程访问
系统配置文件路径:
```shell
/var/lib/pgsql/10/data/postgresql.conf
```
打开配置文件，进行如下修改:
```shell
listen_address='*'
```
重启服务:
```shell
sudo systemctl restart postgresql
```
使用ss实用程序验证更改：
```shell
ss -nlt | grep 5432
```
上面的输出显示PostgreSQL服务器正在所有接口（0.0.0.0）的默认端口上侦听。

最后一步是通过编辑/var/lib/pgsql/data/pg_hba.conf文件将服务器配置为接受远程连接。
以下是一些显示不同用例的示例：
```shell
# TYPE  DATABASE        USER            ADDRESS                 METHOD
 
# The user jane can access all databases from all locations using an md5 password
host    all             jane            0.0.0.0/0                md5
 
# The user jane can access only the janedb database from all locations using an md5 password
host    janedb          jane            0.0.0.0/0                md5
 
# The user jane can access all databases from a trusted location (192.168.1.134) without a password
host    all             jane            192.168.1.134            trust
```



方法	说明	方法	说明
GET	获取资源	DELETE	删除资源
POST	传输数据	HEAD	获得报文首部
PUT	传输文件	OPTIONS	询问支持的方法

0.常见的HTTP方法

1. 版本检查

centos 安装pgsql