Início / dba / Perguntas / 36828
Accepted
Juan Carlos Coto
Asked: 2013-03-14 14:15:01 +0800 CST

Como usar melhor o pool de conexões no pool de nível de transação SQLAlchemy para PgBouncer?

  • 772

Usando SQLAlchemy para consultar um banco de dados PostgreSQL atrás de PgBouncer, usando pooling em nível de transação.

Qual é o melhor padrão a ser usado para esse tipo de configuração? Devo ter um mecanismo por processo, usando um ConnectionPool, ou devo criar um mecanismo por solicitação e usar NullPoolpara cada um deles? Existe um padrão completamente diferente que eu deveria usar?

Muito obrigado! Deixe-me saber se mais informações são necessárias e atualizarei o mais rápido possível.

postgresql python

2 respostas

  1. Best Answer

    com o PGBouncer, você provavelmente gostaria de ficar com o NullPool. Nesse caso, você poderá compartilhar um único mecanismo entre os subprocessos, pois nenhuma conexão de soquete será transportada para o limite do subprocesso. Mas você não pode compartilhar nada referente a um objeto Connection, como uma Session com uma transação ativa, além desse limite. Você definitivamente não gostaria de fazer "mecanismo por solicitação", porém, um mecanismo é um objeto caro que acumula muitas informações sobre um determinado URL de banco de dados na primeira vez que o vê.

    • 12

  2. Defina o nome do aplicativo

    Se você espera executar muitos processos, precisa saber de onde eles estão se conectando. O PGBouncer tornará isso invisível para pg_stat_activity. Resolva isso definindo cuidadosamente o application_namecom as informações necessárias:

    # Sets the application name for this connection in the form of
#   application-name:user@host
prog = os.path.basename(sys.argv[0]) or 'desjob'
username = pwd.getpwuid (os.getuid ()).pw_name
hostname = socket.gethostname().split(".")[0]·
args.setdefault('connect_args', {'application_name': "%s:%s@%s" %
    (prog, username, hostname)})
args.setdefault('isolation_level', "AUTOCOMMIT")
engine = create_engine(url, **args)

    Preferir Sessões

    Use sessões, pois as solicitações de um objeto Engine podem gerar e manter várias conexões. Conectar-se ao Postgres não é muito caro, com o PGBouncer é ainda menos. Eu sempre usaria NullPoolpara que as únicas conexões que você verá no Postgres sejam as conexões que estão realmente sendo usadas.

    from sqlalchemy.pool import Pool, NullPool
engine = create_engine(uri, poolclass=NullPool)

    Eliminar transações ociosas

    Se sua intenção é usar o PGBouncer para escalar, é imperativo que você evite deixar as transações travadas em aberto. autocommit Para fazer isso , você precisa ativar . Isso não é simples com o SQLAlchemy... existem três lugares onde algo chamado "autocommit" pode ser definido:

    psycopg2 autocommit

    conn = psycopg2.connect(uri)
conn.autocommit = True

    Presume-se que não seja seguro porque o SQLAlchemy precisa saber o que está acontecendo por baixo.

    Sessão autocommit

    Session = sessionmaker(bind=engine, autocommit=True)
session = Session()

    Isso requer uma entrega cuidadosa e explícita:

    session.begin()
session.execute(...)
session.rollback()

    A chamada de função e o tratamento de exceções são extremamente difíceis porque begin()não commit()podem ser aninhados:

    def A():
  session.begin()
  ...
  session.rollback()

def B():
  session.begin()
  try:
      A() # error, already open

    Neste modo, psycopg2 autocommitparece ser False(o padrão)

    Confirmação automática do mecanismo

    Definir o modo de isolamento do mecanismo para "AUTOCOMMIT"ao criar o mecanismo estabelece um novo comportamento padrão que pode não exigir alterações no código existente.

    engine = create_engine(uri, isolation_level="AUTOCOMMIT")

    Neste modo, o psycopg2 autocommitparece serTrue

    O grande problema aqui é que a única forma de garantir que um bloco de código seja encapsulado em uma transação é emitir as instruções manualmente:

    session.execute("BEGIN")
#...
session.execute("COMMIT")
    • 8

relate perguntas