Pkold

linux master password postgresql 主从 安装 配置

从入门到差点放弃,postgresql极简安装+主从配置

postgresql安装,配置主从

安装

解压后

pgsql/bin/initdb -D /usr/local/pgsql/data
local/pgsql/bin/postgres -D /usr/local/pgsql/data >logfile 2>&1 &
local/pgsql/bin/createdb test
local/pgsql/bin/psql test

账户设置

创建用户

CREATE USER oschina WITH PASSWORD 'oschina123';
CREATE ROLE adam WITH LOGIN CREATEDB PASSWORD '654321';  记得添加login权限

改密码

ALTER ROLE davide WITH PASSWORD 'hu8jmn3';

让一个角色能够创建其他角色和新的数据库:

ALTER ROLE miriam CREATEROLE CREATEDB;

查看所有数据库

psql -l 

删除数据库

dropdb mydb

使用数据库

psql mydb

创建数据库

createdb mydb

配置主从

1.主创建同步账号

CREATE USER replica replication LOGIN CONNECTION LIMIT 3 ENCRYPTED PASSWORD 'replica';

2,postgresql.conf

wal_level = hot_standby  # 这个是设置主为wal的主机

max_wal_senders = 32 # 这个设置了可以最多有几个流复制连接,差不多有几个从,就设置几个
wal_keep_segments = 256 # 设置流复制保留的最多的xlog数目
wal_sender_timeout = 60s # 设置流复制主机发送数据的超时时间
max_connections = 100 # 这个设置要注意下,从库的max_connections必须要大于主库的

3,

pg_hda.conf

host    all     all     0.0.0.0/0       md5

4,

pg_basebackup -F p --progress -D /data/replica -h 192.168.1.12 -p 5432 -U replica --password 

5,复制recovery.conf

6,re的内容

standby_mode = on  # 这个说明这台机器为从库
primary_conninfo = 'host=10.12.12.10 port=5432 user=replica password=replica'  # 这个说明这台机器对应主库的信息

recovery_target_timeline = 'latest' # 这个说明这个流复制同步到最新的数据

postgresql。conf

max_connections = 1000 # 一般查多于写的应用从库的最大连接数要比较大

hot_standby = on  # 说明这台机器不仅仅是用于数据归档,也用于数据查询
max_standby_streaming_delay = 30s # 数据流备份的最大延迟时间
wal_receiver_status_interval = 1s  # 多久向主报告一次从的状态,当然从每次数据复制都会向主报告状态,这里只是设置最长的间隔时间
hot_standby_feedback = on # 如果有错误的数据复制,是否向主进行反馈

测试成果

主的机器上sender进程 从的机器上receiver进程

主的机器上

select * from pg_stat_replication;
pid              | 8467       # sender的进程
usesysid         | 44673      # 复制的用户id
usename          | replica    # 复制的用户用户名
application_name | walreceiver  
client_addr      | 10.12.12.12 # 复制的客户端地址
client_hostname  |
client_port      | 55804  # 复制的客户端端口
backend_start    | 2015-05-12 07:31:16.972157+08  # 这个主从搭建的时间
backend_xmin     |
state            | streaming  # 同步状态 startup: 连接中、catchup: 同步中、streaming: 同步
sent_location    | 3/CF123560 # Master传送WAL的位置
write_location   | 3/CF123560 # Slave接收WAL的位置
flush_location   | 3/CF123560 # Slave同步到磁盘的WAL位置
replay_location  | 3/CF123560 # Slave同步到数据库的WAL位置
sync_priority    | 0  #同步Replication的优先度
                      0: 异步、1~?: 同步(数字越小优先度越高)
sync_state       | async  # 有三个值,async: 异步、sync: 同步、potential: 虽然现在是异步模式,但是有可能升级到同步模式

最后注意几个坑

  • systemd 启动的话 配置文件可能在etc下

  • hba配置文件放开ip

  • 创建用户时给的权限

  • 记得给文件夹postgres的 用户组和用户身份

ab aiohttp linux python python3.6 python3.7 torando uvloop

python3.7 和python3.6 压力测试 aiohttp-tornado-uvloop

aiohttp-tornado-uvloop 在python3.7下进行了压力测试

统一的ab

ab -n 10000 -c 1000 "http://0.0.0.0:8080/"

结果

aiohttp
    asyncio
        3.7 : 4000
        3.6 : 3300
    uvloop
        3.7 : 4300
        3.6 : 4700
tornado
    ioloop
        3.7 : 3100
        3.6 : 1300
    uvloop
        3.7 : 1700
        3.6 : 1700

aiohttp

from aiohttp import web

async def handle(request):
    name = request.match_info.get('name', "Anonymous")
    text = "Hello, " + name
    return web.Response(text=text)

app = web.Application()
app.add_routes([web.get('/', handle),
                web.get('/{name}', handle)])

web.run_app(app)

aiohttp + uvloop

from aiohttp import web
import uvloop
import asyncio
async def handle(request):
    name = request.match_info.get('name', "Anonymous")
    text = "Hello, " + name
    return web.Response(text=text)

app = web.Application()
app.add_routes([web.get('/', handle),
                web.get('/{name}', handle)])
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
loop = asyncio.get_event_loop()
app._set_loop(loop)

web.run_app(app)

tornado

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8080)
    tornado.ioloop.IOLoop.current().start()

tornado + uvloop

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

import uvloop
import asyncio

from tornado.platform.asyncio import BaseAsyncIOLoop


class TornadoUvloop(BaseAsyncIOLoop):

    def initialize(self, **kwargs):
        loop = uvloop.new_event_loop()
        try:
            super(TornadoUvloop, self).initialize(
                loop, close_loop=True, **kwargs)
        except Exception:
            loop.close()
            raise

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8080)
    tornado.ioloop.IOLoop.configure(TornadoUvloop)
    tornado.ioloop.IOLoop.current().start()

依赖

aiohttp==3.3.2
async-timeout==3.0.0
attrs==18.1.0
chardet==3.0.4
idna==2.7
multidict==4.3.1
tornado==5.0.2
uvloop==0.10.2
yarl==1.2.6

看来python3.7的asyncio的速度有很大的提升

3.7.0 anaconda conda linux miniconda python

linux 下安逸的食用 python 3.7.0

论最小代价切换使用python3.7

python 3.7.0 出来了 到处都是水文

那么如何最快的速度上手体验

下载miniconda

https://mirrors.ustc.edu.cn/anaconda/miniconda/

安装

bash miniconda-xxxxxxxx-.sh

切换到虚拟环境

source ~/miniconda/bin/activate

安装python3.7.0

conda create --name python37 python=3.7

切换到3.7.0

conda activate python37
deepin linux nopassword opensuse sudo sudoer

sudo 配置密码默认超时时间

sudo 配置密码默认超时时间

之前一直用的是nopasswd = =,然后觉得似乎不大好

好吧

sudoer 可以配置 第一次输入密码后的超时时长

vim /etc/sudoer

添加上一行

Defaults        env_reset,timestamp_timeout=30


#30 代表了30分钟

如图

完美!

测试成功

asyncio eventloop python 多线程 异步

python 中的run_in_executor 和 run_on_executor 实现在异步中调用阻塞函数

python 异步是怎样练成的!

有个挺好玩的东西 python中asyncio 有两个函数 run_in_executorrun_on_executor

run_on_executor 用法

##这部分懒得写demo了 随意找地方复制的 = =

from concurrent.futures import ThreadPoolExecutor
from tornado.ioloop import IOLoop
from tornado.concurrent import run_on_executor

class SleepHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(10)
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self):
        start = time.time()
        res = yield self.sleep()
        self.write("when i sleep %f s" % (time.time() - start))
        self.finish()

    @run_on_executor
    def sleep(self):
        time.sleep(5)
        return 5

run_in_executor 用法

class Index(basic):
    async def get(self):
        name =  self.request.match_info.get('name', "Anonymous")
        text = "Hello, " + name
        loop = asyncio.get_event_loop()
        print(loop.__hash__())
        c = await  loop.run_in_executor(None,fuck,"asasas")
        return self.outJson(text=c)

def fuck(data)->str:
    return data+"async!!!"

似乎差别不是很大 = =

继续折腾!

apt tim upgrade

apt 更新时忽略某个包

apt忽略更新

当使用 apt upgrade 命令时,默认会将所有需要更新的包都下载更新

apt-mark hold xxx

使用这个命令可以将指定的包的版本hold住,这样在更新的时候就会忽略掉这个包。

apt-mark unhold xxx

将 hold 替换为 unhold 就可以取消对这个包版本的锁定了。

aiohttp asyncio callback linux tornado

aiohttp 类 tornado 代码风格模式去开发 !!!完美阿!!!!

使用aiohttp进行tornado代码风格的开发

仔细读了一下 aiohttp 的文档

http://aiohttp.readthedocs.io/en/stable/index.html

= = 竟然!!!

竟然有了!!!!!

类tornado开发特色的!!! 贼开心

from aiohttp import web
class basic(web.View):
    def out(self,text):
        return web.Response(text=text)
class Index(basic):
    async def get(self):
        name = self.request.match_info.get('name', "Anonymous")
        text = "Hello, " + name
        return self.out(text=text)
app = web.Application()
app.add_routes([web.view('/', Index),])
if __name__ == "__main__":
    web.run_app(app)
jieba search whoosh 分词 搜索

博客使用whoosh+jieba作搜索

whoosh作引擎,jieba作分词,实现搜索功能

博客一直没有搜索,本来想用es ,但是想用更硬核一点的所以选用了whoosh ,whoosh是纯py编写的

上代码

单例模式初始化一次whoosh

更新后注销调对象

唯一难受的是 博客从30m/上下的内存占用 彪升到226m!!!!!!!!!!

网上的whoosh 都是贼简单的demo

import os
from jieba.analyse import ChineseAnalyzer
from whoosh.qparser import MultifieldParser
from services import Singleton
from logic.articleDao import articleDao
from whoosh.index import create_in
from whoosh.fields import Schema,ID,TEXT
ana=ChineseAnalyzer()
class Search(metaclass=Singleton):
    def __init__(self):
        self.list = articleDao.listAllNoPage()
        schema = Schema(
            id=ID(stored=True, analyzer=ana),
            title=TEXT(stored=True, analyzer=ana),
            content=TEXT(stored=True, analyzer=ana),
            keyword=TEXT(stored=True, analyzer=ana),
            desc=TEXT(stored=True, analyzer=ana),)
        if not os.path.exists("index"):
            os.mkdir("index")
        ix= create_in("index",schema)
        writer = ix.writer()
        for art in self.list:
            writer.add_document(
                            id=str(art.id),
                           title=art.title,
                           content=art.content,
                           keyword=art.keyword,
                           desc=art.desc)
        writer.commit()
        self.ix= ix

    def search(self,keyword):
        searcher = self.ix.searcher()
        query = MultifieldParser(["content","title","desc","keyword"],schema=self.ix.schema).parse(keyword)
        res=searcher.search(query,limit=len(self.list))
        result = []
        for r in res:
            result.append(r.get("id"))
        searcher.close()
        return result

    @classmethod
    def clear(cls):
        cls._instances = {}
linux mysql tidb

TiDB 用户账户管理

几乎完全兼容mysql的tidb的用户管理


title: TiDB 用户账户管理 category: user guide


TiDB 用户账户管理

用户名和密码

TiDB 将用户账户存储在 mysql.user 系统表里面。每个账户由用户名和 host 作为标识。每个账户可以设置一个密码。

通过 MySQL 客户端连接到 TiDB 服务器,通过指定的账户和密码登陆:

shell> mysql --port 4000 --user xxx --password

使用缩写的命令行参数则是:

shell> mysql -P 4000 -u xxx -p

添加用户

添加用户有两种方式:

  • 通过标准的用户管理的 SQL 语句创建用户以及授予权限,比如 CREATE USERGRANT
  • 直接通过 INSERTUPDATEDELETE 操作授权表。

推荐的方式是使用第一种。第二种方式修改容易导致一些不完整的修改,因此不推荐。还有另一种可选方式是使用第三方工具的图形化界面工具。

下面的例子用 CREATE USERGRANT 语句创建了四个账户:

mysql> CREATE USER 'finley'@'localhost' IDENTIFIED BY 'some_pass';
mysql> GRANT ALL PRIVILEGES ON *.* TO 'finley'@'localhost' WITH GRANT OPTION;
mysql> CREATE USER 'finley'@'%' IDENTIFIED BY 'some_pass';
mysql> GRANT ALL PRIVILEGES ON *.* TO 'finley'@'%' WITH GRANT OPTION;
mysql> CREATE USER 'admin'@'localhost' IDENTIFIED BY 'admin_pass';
mysql> GRANT RELOAD,PROCESS ON *.* TO 'admin'@'localhost';
mysql> CREATE USER 'dummy'@'localhost';

使用 SHOW GRANTS 可以看到为一个用户授予的权限:

mysql> SHOW GRANTS FOR 'admin'@'localhost';
+-----------------------------------------------------+
| Grants for admin@localhost                          |
+-----------------------------------------------------+
| GRANT RELOAD, PROCESS ON *.* TO 'admin'@'localhost' |
+-----------------------------------------------------+

删除用户

使用 DROP USER 语句可以删除用户,例如:

mysql> DROP USER 'jeffrey'@'localhost';

保留用户账户

TiDB 在数据库初始化时会生成一个 'root'@'%' 的默认账户。

设置资源限制

暂不支持。

设置密码

TiDB 将密码存在 mysql.user 系统数据库里面。只有拥有 CREATE USER 权限,或者拥有 mysql 数据库权限( INSERT 权限用于创建, UPDATE 权限用于更新)的用户才能够设置或修改密码。

CREATE USER 创建用户时可以通过 IDENTIFIED BY 指定密码:

CREATE USER 'jeffrey'@'localhost' IDENTIFIED BY 'mypass';

为一个已存在的账户修改密码,可以通过 SET PASSWORD FOR 或者 ALTER USER 语句完成:

SET PASSWORD FOR 'root'@'%' = 'xxx';

或者

ALTER USER 'jeffrey'@'localhost' IDENTIFIED BY 'mypass';

更多在官方文档 https://github.com/pingcap/docs-cn

aiozmq async asyncio python rpc zeromq zmq

aiozmq 最简单使用 ,应该可以用在tornado 同步驱动转异步操作

基于zeromq的rpc组件 ,用起来比zeromq更简单

服务端

import asyncio
from aiozmq import rpc
import random

class Handler(rpc.AttrHandler):
    @rpc.method
    def remote(self, arg1, arg2):
        asyncio.sleep(random.randint(0,9))
        return arg1 + arg2

@asyncio.coroutine
def go():
    server =  yield from rpc.serve_rpc(Handler(),
                                       bind='ipc://a')
    yield from server.wait_closed()
if __name__ == "__main__":
    asyncio.get_event_loop().run_until_complete(go())
    print("DONE")

客户端

import asyncio
from aiozmq import rpc

@asyncio.coroutine
def go():
    client = yield from rpc.connect_rpc(connect='ipc://a')
    for a in range(1,50000):
        ret = yield from client.call.remote(a, 2)
        print(ret)

asyncio.get_event_loop().run_until_complete(go())

最简单的demo- - 应该还能结合 zeromq的router 进行分布式多进程 worker