Паксос (информатика) - Википедия - Paxos (computer science)

Паксос это семейство протоколов для решения консенсус в сети ненадежных или ошибочных процессоров. Консенсус - это процесс согласования одного результата группой участников. Эта проблема усложняется, когда участники или их коммуникации могут испытывать сбои.^[1]

Протоколы консенсуса являются основой для репликация конечного автомата подход к распределенным вычислениям, предложенный Лесли Лэмпорт^[2] и опрошено Фред Шнайдер.^[3] Репликация конечного автомата - это метод преобразования алгоритма в отказоустойчивую распределенную реализацию. Специальные методы могут оставить нерешенными важные случаи сбоев. Принципиальный подход, предложенный Lamport et al. обеспечивает безопасное обращение со всеми случаями.

Протокол Paxos был впервые представлен в 1989 году и назван в честь вымышленной законодательной системы консенсуса, используемой в Паксос остров в Греции, где Лэмпорт писал, что парламент должен был функционировать, «хотя законодатели постоянно бродили в палате парламента и выходили из нее».^[4] Позже она была опубликована в виде журнальной статьи в 1998 году.^[5]

Семейство протоколов Paxos включает в себя спектр компромиссов между количеством процессоров, количеством задержек сообщений до определения согласованного значения, уровнем активности отдельных участников, количеством отправленных сообщений и типами сбоев. Хотя никакой детерминированный отказоустойчивый консенсусный протокол не может гарантировать прогресс в асинхронной сети (результат доказан в статье Фишер, Линч и Патерсон^[6]), Paxos гарантирует безопасность (постоянство), а условия, которые могут помешать прогрессу, сложно спровоцировать.

Paxos обычно используется там, где требуется долговечность (например, для репликации файла или базы данных), в которых длительное состояние может быть большим. Протокол пытается добиться прогресса даже в периоды, когда некоторое ограниченное количество реплик не отвечает. Также существует механизм удаления постоянно отказавшей реплики или добавления новой реплики.

История

Тема предшествует протоколу. В 1988 г. Линч, Dwork и Stockmeyer продемонстрировал ^[7] разрешимость консенсуса в широком семействе «частично синхронных» систем. Paxos имеет сильное сходство с протоколом, используемым для согласования "репликации с отметкой просмотра", впервые опубликованным Oki и Лисков в 1988 г. в контексте распределенных транзакций.^[8] Несмотря на эту предыдущую работу, Paxos предложил особенно элегантный формализм и включил одно из первых доказательств безопасности отказоустойчивого протокола распределенного консенсуса.

Реконфигурируемые конечные автоматы тесно связаны с предыдущей работой над надежными протоколами групповой многоадресной рассылки, которые поддерживают динамическое членство в группах, например Бирман работы в 1985 и 1987 гг. практически синхронный gbcast^[9] протокол. Однако gbcast необычен с точки зрения поддержки устойчивости и устранения сбоев разделения. Большинство надежных протоколов многоадресной рассылки лишены этих свойств, которые требуются для реализации модели репликации конечного автомата. Этот момент подробно рассматривается в статье Lamport, Малхи и Чжоу.^[10]

Протоколы Paxos являются членами теоретического класса решений проблемы, формализованной как единое соглашение с аварийными отказами. Нижние границы для этой проблемы были доказаны Кейдаром и Шраером.^[11]. Деречо^[12], программная библиотека C ++ для репликации конечного автомата в масштабе облака, предлагает протокол Paxos, интегрированный с самоуправляемым виртуально синхронным членством. Этот протокол соответствует границам оптимальности Кейдара и Шраера и эффективно соответствует современным требованиям. удаленный DMA (RDMA) оборудование центра обработки данных (но использует TCP, если RDMA недоступен).

Предположения

Чтобы упростить представление Paxos, следующие предположения и определения сделаны явными. Методы расширения области применения известны в литературе и не рассматриваются в этой статье.

Процессоров

• Процессоры работают с произвольной скоростью.
• В процессорах могут возникать сбои.
• Процессоры со стабильным хранилищем могут повторно подключиться к протоколу после сбоев (в соответствии с моделью сбоя восстановления после сбоя).
• Процессоры не вступают в сговор, не лгут и не пытаются иным образом подорвать протокол. (То есть, Византийские неудачи не происходит. Видеть Византийский Паксос для решения, которое допускает сбои, возникающие из-за произвольного / злонамеренного поведения процессов.)

Сеть

• Процессоры могут отправлять сообщения любому другому процессору.
• Сообщения отправляются асинхронно, и доставка может длиться сколь угодно долго.
• Сообщения могут быть потеряны, переупорядочены или дублированы.
• Сообщения доставляются без искажений. (То есть византийских неудач не бывает. См. Византийский Паксос для решения, которое допускает поврежденные сообщения, возникающие в результате произвольного / злонамеренного поведения каналов обмена сообщениями.)

Количество процессоров

В общем, алгоритм консенсуса может добиться прогресса, используя ${ Displaystyle п = 2F + 1}$ процессоров, несмотря на одновременный отказ любого ${ displaystyle F}$ процессоры ^[13]: другими словами, количество исправных процессов должно быть строго больше, чем количество ошибочных процессов. Однако, используя реконфигурацию, можно использовать протокол, который выдерживает любое количество полных отказов до тех пор, пока не выйдет из строя более F одновременно. Для протоколов Paxos эти изменения конфигурации могут выполняться как отдельные конфигурации^[14].

Роли

Paxos описывает действия процессоров по их ролям в протоколе: клиент, принимающий, предлагающий, учащийся и лидер. В типичных реализациях один процессор может играть одну или несколько ролей одновременно. Это не влияет на правильность протокола - обычно роли объединяются для уменьшения задержки и / или количества сообщений в протоколе.

Клиент

Клиент выдает запрос в распределенную систему и ждет отклик. Например, запрос на запись в файл на распределенном файловом сервере.

Акцептант (избиратели)

Акцепторы действуют как отказоустойчивая «память» протокола. Приемлемые собираются в группы, называемые кворумами. Любое сообщение, отправленное Получателю, должно быть отправлено в Кворум Получателей. Любое сообщение, полученное от получателя, игнорируется, если только его копия не получена от каждого получателя в кворуме.

Предлагающий

Предлагающий защищает запрос клиента, пытаясь убедить принимающих согласиться с ним, и действует как координатор для продвижения протокола вперед при возникновении конфликтов.

Ученик

Учащиеся действуют как фактор репликации для протокола. После того, как запрос клиента был согласован с принимающими сторонами, учащийся может предпринять действия (то есть: выполнить запрос и отправить ответ клиенту). Чтобы улучшить доступность обработки, можно добавить дополнительных учащихся.

Лидер

Paxos требует выдающегося Предлагающего (так называемого лидера) для достижения прогресса. Многие процессы могут считать себя лидерами, но протокол гарантирует прогресс только в том случае, если в конечном итоге будет выбран один из них. Если два процесса считают себя лидерами, они могут остановить выполнение протокола, постоянно предлагая противоречивые обновления. Тем не менее свойства безопасности все еще сохраняются в этом случае.

Кворумы

Кворумы отражают свойства безопасности (или согласованности) Paxos, гарантируя, что по крайней мере какой-то сохранившийся процессор сохранит информацию о результатах.

Кворумы определяются как подмножества множества Принимающих, так что любые два подмножества (то есть любые два Кворума) имеют по крайней мере одного члена. Как правило, Кворум составляет любое большинство принимающих участие. Например, учитывая набор Акцепторов {A, B, C, D}, большинство Кворума будут любыми тремя Акцепторами: {A, B, C}, {A, C, D}, {A, B, D} , {B, C, D}. В более общем плане акцепторам могут быть присвоены произвольные положительные веса; в этом случае Кворум можно определить как любое подмножество Акцепторов, суммарный вес которых превышает половину общего веса всех Акцепторов.

Номер предложения и согласованная стоимость

Каждая попытка определить согласованную стоимость v выполняется с предложениями, которые могут быть приняты или не приняты Акцептаторами. Каждое предложение имеет уникальный номер для данного заявителя. Так, например, каждое предложение может иметь форму (п, v), куда п уникальный идентификатор предложения и v фактическое предлагаемое значение. Значение, соответствующее пронумерованному предложению, может быть вычислено как часть работы протокола Paxos, но не обязательно.

Свойства безопасности и живучести

Чтобы гарантировать безопасность (также называемое «согласованность»), Paxos определяет три свойства и гарантирует, что первые два всегда сохраняются, независимо от схемы сбоев:

Срок действия (или нетривиальность)

Можно выбрать и изучить только предлагаемые значения.^[15]

Соглашение (или последовательность, или же безопасность)

Никакие два разных ученика не могут усвоить разные ценности (или не может быть более одного определенного значения)^[15][16]

Прекращение (или жизнеспособность)

Если было предложено значение C, то в конечном итоге обучающийся L узнает некоторое значение (если достаточное количество процессоров останется исправным).^[16]

Обратите внимание, что Paxos нет гарантированно завершается, и поэтому не имеет свойства liveness. Это подтверждается результатом невозможности Фишера Линча Патерсона (FLP).^[6] в котором говорится, что протокол согласованности может иметь только два из безопасность, живость, и Отказоустойчивость. Поскольку цель Paxos - обеспечить отказоустойчивость и безопасность, она также не может гарантировать живучесть.

Типичное развертывание

В большинстве развертываний Paxos каждый участвующий процесс выполняет три роли; Предлагающий, принимающий и учащийся.^[17] Это значительно снижает сложность сообщения без ущерба для правильности:

В Paxos клиенты отправляют команды лидеру. Во время нормальной работы лидер принимает команду клиента, присваивает ей новый номер команды i, а затем начинает i-й экземпляр алгоритма консенсуса, отправляя сообщения набору процессов-приемников.^[16]

Путем слияния ролей протокол «сворачивается» в эффективное развертывание в стиле клиент-мастер-реплика, типичное для сообщества баз данных. Преимущество протоколов Paxos (включая реализации с объединенными ролями) - гарантия их свойства безопасности.

Типичный поток сообщений реализации описан в разделе Multi-Paxos.

Базовый Паксос

Этот протокол является самым основным из семейства Paxos. Каждый «экземпляр» (или «выполнение») основного протокола Paxos определяет единственное выходное значение. Протокол проходит в несколько раундов. Успешный раунд состоит из 2 фаз: фаза 1 (которая разделена на части а и б) и этап 2 (который разделен на части а и б). См. Ниже описание фаз. Помните, что мы предполагаем асинхронную модель, поэтому, например, процессор может находиться в одной фазе, а другой процессор может находиться в другой.

Фаза 1

Фаза 1а: Подготовить

А Предлагающий создает сообщение, которое мы называем «Подготовить», с номером п. Обратите внимание, что п это не значение, которое будет предложено и, возможно, согласовано, а просто число, которое однозначно идентифицирует это первоначальное сообщение предлагающим (для отправки принимающим). Номер п должно быть больше любого числа, использованного в любом из предыдущих Подготовить сообщения этого Предлагающего. Затем он отправляет Подготовить сообщение, содержащее п к Кворум из Акцепторы. Обратите внимание, что Подготовить сообщение содержит только номер п (то есть он не обязательно должен содержать, например, предлагаемое значение, часто обозначаемое v). Претендент решает, кто входит в Кворум^{[как? ]}. Предлагающий не должен инициировать Paxos, если он не может связаться, по крайней мере, с Кворумом принимающих.

Фаза 1b: Обещать

Любой из Акцепторы ждет Подготовить сообщение от любого из Предлагающие. Если Acceptor получает сообщение Prepare, Acceptor должен посмотреть на номер идентификатора. п из только что полученных Подготовить сообщение. Есть два случая.

Если п больше, чем номер каждого предыдущего предложения, полученного от любого из предлагающих, акцептатором, то акцептант должен вернуть сообщение, которое мы называем «обещанием», чтобы он игнорировал все будущие предложения, имеющие номер меньше п. Если Акцептатор принято предложение в какой-то момент в прошлом, оно должно включать номер предыдущего предложения, скажем м, и соответствующее принятое значение, скажем ш, в своем ответе заявителю.

В противном случае (то есть п меньше или равно любому предыдущему номеру предложения, полученному от любого Предлагающего Акцептатором) Акцептатор может проигнорировать полученное предложение. В этом случае для работы Paxos не нужно отвечать. Однако в целях оптимизации отправка отказа (Nack ) ответ сообщит Предлагающему, что он может прекратить попытки достичь консенсуса с предложением п.

Фаза 2

Фаза 2а: Принимать

Если предлагающий получает большинство обещаний от кворума акцептов, ему необходимо установить значение v к своему предложению. Если какие-либо акцептанты ранее принимали какое-либо предложение, они отправят свои значения Предлагающему, который теперь должен установить значение своего предложения, vк значению, связанному с наивысшим номером предложения, сообщенным Акцепторами, назовем его z. Если ни один из Акцепторов не принял предложение до этого момента, то Предлагающий может выбрать значение, которое он изначально хотел предложить, например Икс^[18].

Претендент отправляет Принимать сообщение, (п, v), в Кворум Акцепторов с выбранным значением для его предложения, v, и номером предложения п (который совпадает с числом, содержащимся в Подготовить сообщение, ранее отправленное Получателям). Итак Принимать сообщение либо (п, v = z) или, если ни один из Акцепторов ранее не принял значение, (п, v = х).

Этот Принимать сообщение следует интерпретировать как «запрос», например «Примите это предложение, пожалуйста!».

Фаза 2b: Принято

Если Acceptor получает сообщение Accept, (п, v)от Предлагающего, он должен принять его если и только если она имеет нет уже обещал (на этапе 1b протокола Paxos) рассматривать только предложения с идентификатором больше п.

Если Акцептант еще не пообещал (на Этапе 1b) рассматривать только предложения с идентификатором, превышающим п, он должен зарегистрировать значение v (из только что полученных Принимать сообщение) в качестве принятого значения (протокола) и отправить Принято сообщение для предлагающего и каждого учащегося (которым обычно могут быть сами предлагающие).

В противном случае он может игнорировать сообщение или запрос «Принять».

Обратите внимание, что Акцептатор может принимать несколько предложений. Это может произойти, когда другой предлагающий, не зная о новом значении, начинает новый раунд с более высоким идентификационным номером. п. В этом случае Acceptor может пообещать, а затем принять новое предложенное значение, даже если он принял другое ранее. Эти предложения могут даже иметь разные значения при наличии определенных сбоев.^{[пример необходим ]}. Однако протокол Paxos гарантирует, что Акцептаторы в конечном итоге согласятся с единым значением.

Когда раунды терпят неудачу

Раунды не удаются, когда несколько предлагающих отправляют конфликтующие Подготовить сообщения, или когда Предлагающий не получает Кворум ответов (Обещать или же Принято). В этих случаях необходимо начать еще один раунд с более высоким номером предложения.

Paxos можно использовать для выбора лидера

Обратите внимание, что, когда Акцептаторы принимают запрос, они также признают лидерство Претендента.^{[как? ]}. Следовательно, Paxos можно использовать для выбора лидера в кластере узлов.^{[требуется разъяснение ]}.

Графическое представление потока сообщений в базовом Paxos

На следующих диаграммах представлены несколько случаев / ситуаций применения протокола Basic Paxos. В некоторых случаях показано, как протокол Basic Paxos справляется с отказом определенных (избыточных) компонентов распределенной системы.

Обратите внимание, что значения, возвращаемые в Обещать сообщения являются "нулевыми" при первом внесении предложения (поскольку ни один Акцептатор не принял значение ранее в этом раунде).

Базовый Paxos без сбоев

На диаграмме ниже 1 клиент, 1 предлагающий, 3 принимающих (т. Е. Размер кворума равен 3) и 2 учащихся (представлены двумя вертикальными линиями). Эта диаграмма представляет случай первого раунда, который является успешным (т.е. ни один процесс в сети не завершился ошибкой).

Клиент, предлагающий акцептор, обучающийся | | | | | | | X --------> | | | | | | Запрос | X ---------> | -> | -> | | | Подготовить (1) | | <--------- X - X - X | | Обещание (1, {Va, Vb, Vc}) | X ---------> | -> | -> | | | Принимаю! (1, V) | | <---------X--X--X------> | -> | Принято (1, V) | <--------------------------------- X - X Response | | | | | | |

Здесь V - последнее из (Va, Vb, Vc).

Случаи ошибок в базовом Paxos

Самыми простыми случаями ошибок являются отказ Acceptor (когда кворум Acceptor остается живым) и отказ избыточного Learner. В этих случаях протокол не требует «восстановления» (т. Е. Все равно успешно): никаких дополнительных раундов или сообщений не требуется, как показано ниже (на следующих двух диаграммах / случаях).

Базовый Paxos при отказе акцептора

На следующей диаграмме один из приемников в кворуме выходит из строя, поэтому размер кворума становится равным 2. В этом случае протокол Basic Paxos все еще работает успешно.

Клиент, предлагающий акцептор, обучающийся | | | | | | | X --------> | | | | | | Запрос | X ---------> | -> | -> | | | Подготовить (1) | | | | ! | | !! ПРОВАЛ !! | | <--------- X - X | | Обещание (1, {Va, Vb, null}) | X ---------> | -> | | | Принимаю! (1, V) | | <---------X--X---------> | -> | Принято (1, V) | <--------------------------------- X - X Response | | | | | |

Базовый Paxos, когда избыточный ученик терпит неудачу

В следующем случае один из (избыточных) учащихся выходит из строя, но протокол Basic Paxos все равно работает.

Клиент, предлагающий акцептор, обучающийся | | | | | | | X --------> | | | | | | Запрос | X ---------> | -> | -> | | | Подготовить (1) | | <--------- X - X - X | | Обещание (1, {Va, Vb, Vc}) | X ---------> | -> | -> | | | Принимаю! (1, V) | | <---------X--X--X------> | -> | Принято (1, V) | | | | | | ! !! ПРОВАЛ !! | <--------------------------------- Ответ X | | | | | |

Базовый Paxos, когда предлагающий терпит неудачу

В этом случае Предлагающий терпит неудачу после предложения значения, но до достижения соглашения. В частности, он не работает в середине сообщения Accept, поэтому только один Acceptor из кворума получает значение. Тем временем избирается новый Лидер (Предлагающий) (но это подробно не показано). Обратите внимание, что в этом случае есть 2 раунда (раунды идут вертикально, сверху вниз).

Клиент, предлагающий акцептор, обучающийся | | | | | | | X -----> | | | | | | Запрос | X ------------> | -> | -> | | | Подготовить (1) | | <------------ X - X - X | | Обещание (1, {Va, Vb, Vc}) | | | | | | | | | | | | | | !! Лидер выходит из строя во время трансляции !! | X ------------> | | | | | Принимаю! (1, V) | ! | | | | | | | | | | | | !! НОВЫЙ ЛИДЕР !! | X ---------> | -> | -> | | | Подготовить (2) | | <--------- X - X - X | | Обещание (2, {V, null, null}) | X ---------> | -> | -> | | | Принимаю! (2, V) | | <---------X--X--X------> | -> | Принято (2, V) | <--------------------------------- X - X Response | | | | | | |

Базовый Paxos при конфликте нескольких предлагающих

Самый сложный случай - когда несколько предлагающих считают себя лидерами. Например, текущий лидер может потерпеть неудачу и позже восстановится, но другие предлагающие уже повторно выбрали нового лидера. Выздоровевший лидер этого еще не усвоил и пытается начать один раунд конфликта с нынешним лидером. На диаграмме ниже показано 4 неудачных раунда, но их может быть больше (как показано внизу диаграммы).

Клиент, предлагающий акцептор, обучающийся | | | | | | | X -----> | | | | | | Запрос | X ------------> | -> | -> | | | Подготовить (1) | | <------------ X - X - X | | Обещание (1, {null, null, null}) | ! | | | | | !! ЛИДЕР НЕУДАЧИ | | | | | | | !! НОВЫЙ ЛИДЕР (знает, что последнее число было 1) | X ---------> | -> | -> | | | Подготовить (2) | | <--------- X - X - X | | Обещание (2, {null, null, null}) | | | | | | | | !! СТАРЫЙ ЛИДЕР выздоравливает | | | | | | | | !! СТАРЫЙ ЛИДЕР пытается 2, отказано | X ------------> | -> | -> | | | Подготовить (2) | | <------------ X - X - X | | Нак (2) | | | | | | | | !! СТАРЫЙ ЛИДЕР пытается 3 | X ------------> | -> | -> | | | Подготовить (3) | | <------------ X - X - X | | Обещание (3, {null, null, null}) | | | | | | | | !! НОВЫЙ ЛИДЕР предлагает, но отказано | | X ---------> | -> | -> | | | Принимаю! (2, Ва) | | | <--------- X - X - X | | Нак (3) | | | | | | | | !! НОВЫЙ ЛИДЕР пытается 4 | | X ---------> | -> | -> | | | Подготовить (4) | | | <--------- X - X - X | | Обещание (4, {null, null, null}) | | | | | | | | !! СТАРЫЙ ЛИДЕР предлагает, но отказано | X ------------> | -> | -> | | | Принимаю! (3, Vb) | | <------------ X - X - X | | Нак (4) | | | | | | | | ... и так далее ...

Multi-Paxos

Типичное развертывание Paxos требует непрерывного потока согласованных значений, действующих как команды для распределенного конечного автомата. Если каждая команда является результатом одного экземпляра Базовый Паксос протокол, это приведет к значительным накладным расходам.

Если лидер относительно стабилен, фаза 1 становится ненужной. Таким образом, можно пропустить фазу 1 для будущих экземпляров протокола с тем же лидером.

Для этого круглое число я включается вместе с каждым значением, которое увеличивается в каждом раунде тем же лидером. Multi-Paxos сокращает задержку безотказного сообщения (от предложения до обучения) с 4 до 2.

Графическое представление потока сообщений в Multi-Paxos

Мультипаксо без сбоев

На следующей диаграмме показан только один экземпляр (или «выполнение») основного протокола Paxos с начальным лидером (предлагающим). Обратите внимание, что Multi-Paxos состоит из нескольких экземпляров базового протокола Paxos.

Клиент, предлагающий акцептор, обучающийся | | | | | | | --- Первый запрос --- X --------> | | | | | | Запрос | X ---------> | -> | -> | | | Подготовить (N) | | <--------- X - X - X | | Обещание (N, I, {Va, Vb, Vc}) | X ---------> | -> | -> | | | Принимаю! (N, I, V) | | <---------X--X--X------> | -> | Принято (N, I, V) | <--------------------------------- X - X Response | | | | | | |

где V = последний из (Va, Vb, Vc).

Multi-Paxos, когда фазу 1 можно пропустить

В этом случае экземпляры подпоследовательности основного протокола Paxos (представленные Я + 1) используют одного и того же лидера, поэтому этап 1 (этих последующих экземпляров базового протокола Paxos), который состоит из подфаз Prepare и Promise, пропускается. Обратите внимание, что Лидер должен быть стабильным, то есть не должен падать или изменяться.

Клиент, предлагающий акцептор, обучающийся | | | | | | | --- Следующие запросы --- X --------> | | | | | | Запрос | X ---------> | -> | -> | | | Принимаю! (N, I + 1, W) | | <---------X--X--X------> | -> | Принято (N, I + 1, W) | <--------------------------------- X - X Ответ | | | | | | |

Multi-Paxos, когда роли свернуты

Обычное развертывание Multi-Paxos состоит в сворачивании роли предлагающих, принимающих и учащихся до «серверов». Итак, в итоге остались только «Клиенты» и «Серверы».

На следующей диаграмме представлен первый «экземпляр» базового протокола Paxos, когда роли Предлагающего, Принимающего и Обучающегося сводятся к одной роли, называемой «Сервер».

Клиентские серверы | | | | --- Первый запрос --- X --------> | | | Запрос | X-> | -> | Подготовить (N) | | <-X - X Promise (N, I, {Va, Vb}) | X-> | -> | Принимаю! (N, I, Vn) | X <> X <> X Принято (N, I) | <-------- X | | Ответ | | | |

Multi-Paxos, когда роли свернуты, а лидер устойчив

В последующих экземплярах базового протокола Paxos с тем же лидером, что и в предыдущих экземплярах базового протокола Paxos, этап 1 можно пропустить.

Клиентские серверы X --------> | | | Запрос | X-> | -> | Принимаю! (N, I + 1, W) | X <> X <> X Принято (N, I + 1) | <-------- X | | Ответ | | | |

Оптимизация

Можно выполнить ряд оптимизаций, чтобы уменьшить количество передаваемых сообщений, повысить производительность протокола и т. Д. Некоторые из этих оптимизаций описаны ниже.

«Мы можем сохранять сообщения за счет дополнительной задержки сообщения, имея одного выдающегося учащегося, который информирует других учащихся, когда узнает, что значение было выбрано. Затем принимающие Принято сообщения только для выдающегося ученика. В большинстве приложений роли лидера и выдающегося ученика выполняет один и тот же процессор. ^[19]

"Лидер может прислать Подготовить и Принимать! сообщения только кворуму принимающих. Пока все принимающие в этом кворуме работают и могут общаться с лидером и учащимися, у принимающих, не входящих в кворум, нет необходимости что-либо делать. ^[19]

«Приемщикам все равно, какое значение выбрано. Они просто реагируют на Подготовить и Принимать! сообщения, чтобы гарантировать, что, несмотря на сбои, можно выбрать только одно значение. Однако, если приемник узнает, какое значение было выбрано, он может сохранить это значение в стабильном хранилище и стереть любую другую информацию, которую он там сохранил. Если позже акцептор получит Подготовить или же Принимать! сообщение, вместо выполнения действия Phase1b или Phase2b, оно может просто проинформировать лидера о выбранном значении. ^[19]

"Вместо того, чтобы посылать значение v, лидер может послать хеш v некоторым получателям в своем Принимать! Сообщения. Учащийся узнает, что выбран v, если он получит Принято сообщения для v или его хэш от кворума принимающих, и по крайней мере одно из этих сообщений содержит v, а не его хэш. Однако лидер мог получить Обещать сообщения, которые сообщают ему хэш значения v, которое он должен использовать в своем действии Phase2a, не сообщая ему фактическое значение v. Если это произойдет, лидер не сможет выполнить свое действие Phase2a, пока не свяжется с некоторым процессом, который знает v ».^[19]

"Предлагающий может отправить свое предложение только лидеру, а не всем координаторам. Однако для этого необходимо, чтобы результат алгоритма выбора лидера был передан предлагающим, что может быть дорогостоящим. Так что, возможно, лучше позволить Претендент направляет свое предложение всем координаторам (в этом случае только сами координаторы должны знать, кто является лидером). ^[15]

"Вместо отправки каждого акцептора Принято сообщения каждому учащемуся, принимающие могут отправлять свои Принято сообщения лидеру и лидеру могут сообщить учащимся, когда значение было выбрано. Однако это добавляет дополнительную задержку сообщения. ^[15]

"Наконец, обратите внимание, что фаза 1 не нужна для раунда 1. Лидер раунда 1 может начать раунд, отправив Принимать! сообщение с любым предложенным значением ".^[15]

Дешевые Паксо

Cheap Paxos расширяется Базовый Паксос выдерживать F-отказы с F + 1 основными процессорами и F вспомогательными процессорами путем динамического перенастройки после каждого сбоя.

Это сокращение требований к процессору происходит за счет живучести; если слишком много основных процессоров выйдут из строя за короткое время, система должна остановиться, пока вспомогательные процессоры не смогут перенастроить систему. В периоды стабильности вспомогательные процессоры не участвуют в протоколе.

"Имея только два процессора p и q, один процессор не может отличить отказ другого процессора от отказа среды связи. Требуется третий процессор. Однако этот третий процессор не должен участвовать в выборе последовательности команд. Он должен предпринимать действия только в случае сбоя p или q, после чего он ничего не делает, пока p или q продолжают управлять системой самостоятельно.Третий процессор может быть небольшим / медленным / дешевым или процессором, в основном предназначенным для других задач . "^[19]

Поток сообщений: дешевые Multi-Paxos

Пример, включающий три основных приемника, один вспомогательный приемник и размер кворума три, демонстрирующий отказ одного основного процессора и последующую реконфигурацию:

            {Acceptors} Предлагающий Главный Aux Learner | | | | | | - Фаза 2 --X -----------> | -> | -> | | | Принимаю! (N, I, V) | | | ! | | --- ПРОВАЛ! --- | <-----------X--X---------------> | Принято (N, I, V) | | | | | - Обнаружен сбой (принято только 2) --X -----------> | -> | -------> | | Accept! (N, I, V) (повторно передать, включить Aux) | <-----------X--X--------X------> | Принято (N, I, V) | | | | | - Перенастроить: Кворум = 2 --X -----------> | -> | | | Accept! (N, I + 1, W) (Aux не участвует) | <-----------X--X---------------> | Принято (N, I + 1, W) | | | | |

Быстрые Паксо

Fast Paxos обобщает Базовый Паксос для уменьшения сквозных задержек сообщений. В Basic Paxos задержка сообщения от запроса клиента до обучения составляет 3 задержки сообщения. Fast Paxos допускает 2 задержки сообщений, но требует, чтобы (1) система состояла из 3f + 1 акцепторы терпеть до ж сбои (вместо классического 2f + 1) и (2) клиент отправляет свой запрос в несколько пунктов назначения.

Интуитивно понятно, что если у лидера нет ценности для предложения, то клиент может отправить Принимать! сообщение к Получателям напрямую. Приемники ответят, как в Basic Paxos, отправив Принято сообщения лидеру и каждому учащемуся, достигая двух задержек сообщения от клиента к учащемуся.

Если лидер обнаруживает столкновение, он разрешает столкновение, отправив Принимать! сообщения для нового раунда, которые Принято как обычно. Этот метод скоординированного восстановления требует четырех задержек сообщений от клиента к учащемуся.

Окончательная оптимизация происходит, когда лидер заранее определяет метод восстановления, позволяя принимающим сторонам самостоятельно выполнять восстановление после столкновения. Таким образом, нескоординированное восстановление после столкновения может происходить за три задержки сообщения (и только две задержки сообщения, если все учащиеся также являются принимающими).

Поток сообщений: Fast Paxos, неконфликтный

Клиент Лидер Acceptor Learner | | | | | | | | | X ---------> | -> | -> | -> | | | Любой (N, I, Recovery) | | | | | | | | X -------------------> | -> | -> | -> | | | Принять! (N, I, W) | | <---------X--X--X--X------> | -> | Принято (N, I, W) | <------------------------------------ X - X Ответ (W) | | | | | | | |

Поток сообщений: Fast Paxos, противоречивые предложения

Противоречивые предложения с согласованным восстановлением. Примечание: протокол не указывает, как обрабатывать отброшенный клиентский запрос.

Клиент Лидер Acceptor Learner | | | | | | | | | | | | | | | | | | | | | | | | | | | !! Параллельно противоречивые предложения | | | | | | | | | !! поступили в разном порядке | | | | | | | | | !! акцепторами | X --------------? | -? | -? | -? | | | Принять! (N, I, V) X -----------------? | -? | -? | -? | | | Принять! (N, I, W) | | | | | | | | | | | | | | | | | | !! Акцепторы расходятся во мнениях по поводу стоимости | | | <-------X--X-> | -> | -----> | -> | Принято (N, I, V) | | | <------- | <- | <-X--X-----> | -> | Принято (N, I, W) | | | | | | | | | | | | | | | | | | !! Обнаружить столкновение и восстановить | | X -------> | -> | -> | -> | | | Принимаю! (N + 1, I, W) | | | <-------X--X--X--X-----> | -> | Принято (N + 1, I, W) | <--------------------------------- X - X ответ (W) | | | | | | | | |

Противоречивые предложения с несогласованным восстановлением.

Клиент Лидер Acceptor Learner | | | | | | | | | | | X -------> | -> | -> | -> | | | Любой (N, I, Recovery) | | | | | | | | | | | | | | | | | | !! Параллельно противоречивые предложения | | | | | | | | | !! поступили в разном порядке | | | | | | | | | !! акцепторами | X --------------? | -? | -? | -? | | | Принять! (N, I, V) X -----------------? | -? | -? | -? | | | Принять! (N, I, W) | | | | | | | | | | | | | | | | | | !! Акцепторы расходятся во мнениях по поводу стоимости | | | <-------X--X-> | -> | -----> | -> | Принято (N, I, V) | | | <------- | <- | <-X--X-----> | -> | Принято (N, I, W) | | | | | | | | | | | | | | | | | | !! Обнаружить столкновение и восстановить | | | <-------X--X--X--X-----> | -> | Принято (N + 1, I, W) | <--------------------------------- X - X ответ (W) | | | | | | | | |

Поток сообщений: Fast Paxos с нескоординированным восстановлением, свернутые роли

(объединенные роли Acceptor / Learner)

Клиентские серверы | | | | | | | | X-> | -> | -> | Любой (N, I, Recovery) | | | | | | | | | | | | !! Параллельно противоречивые предложения | | | | | | !! поступили в разном порядке | | | | | | !! серверами | X --------? | -? | -? | -? | Принять! (N, I, V) X -----------? | -? | -? | -? | Принять! (N, I, W) | | | | | | | | | | | | !! Серверы расходятся во мнениях по стоимости | | X <> X-> | -> | Принято (N, I, V) | | | <- | <-X <> X принято (N, I, W) | | | | | | | | | | | | !! Обнаружить столкновение и восстановить | | X <> X <> X <> X Принято (N + 1, I, W) | <----------- X - X - X - X Ответ (W) | | | | | |

Обобщенный Паксос

Обобщенный консенсус исследует взаимосвязь между операциями реплицированного конечного автомата и консенсусным протоколом, который его реализует. ^[16]. Главное открытие связано с оптимизацией Paxos, когда конфликтующие предложения могут применяться в любом порядке. т.е. когда предлагаемые операции коммутативные операции для государственной машины. В таких случаях могут быть приняты обе конфликтующие операции, что позволяет избежать задержек, необходимых для разрешения конфликтов, и повторно предлагать отклоненные операции.

Эта концепция далее обобщается на постоянно растущие последовательности коммутативных операций, некоторые из которых известны как стабильные (и, следовательно, могут выполняться). Протокол отслеживает эти последовательности, гарантируя, что все предложенные операции одной последовательности стабилизируются, прежде чем разрешить любую операцию, не коммутирующую с ними, стать стабильной.

Пример

Чтобы проиллюстрировать обобщенный Paxos, в приведенном ниже примере показан поток сообщений между двумя одновременно выполняющимися клиентами и реплицированным конечным автоматом, реализующим операции чтения / записи в двух разных регистрах A и B.

Таблица коммутативности

	Читать)	Написать)	Читать (B)	Написать (B)
Читать)
Написать)
Читать (B)
Write(B)

Обратите внимание, что in this table indicates operations which are non-commutative.

A possible sequence of operations :

 <1:Read(A), 2:Read(B), 3:Write(B), 4:Read(B), 5:Read(A), 6:Write(A)> 

С 5:Read(A) ездит с обоими 3:Write(B) и 4:Read(B), one possible permutation equivalent to the previous order is the following:

 <1:Read(A), 2:Read(B), 5:Read(A), 3:Write(B), 4:Read(B), 6:Write(A)> 

In practice, a commute occurs only when operations are proposed concurrently.

Message flow: Generalized Paxos (example)

Responses not shown. Note: message abbreviations differ from previous message flows due to specifics of the protocol, see ^[20] for a full discussion.

Client      Leader  Acceptor       Learner | | | | | | | | !! New Leader Begins Round | | X----->|->|->| | | Prepare(N) | | |<-----X- X- X         | | Promise(N,null) | | X----->|->|->| | | Phase2Start(N,null) | | | | | | | | | | | | | | | | !! Concurrent commuting proposals | X------- ?|-----?|-?|-?| | | Propose(ReadA) X-----------?|-----?|-?|-?| | | Propose(ReadB) | | X------X-------------->|->| Accepted(N,) | | |<--------X--X-------->|->| Accepted(N,) | | | | | | | | | | | | | | | | !! No Conflict, both accepted | | | | | | | | Stable =  | | | | | | | | | | | | | | | | !! Concurrent conflicting proposals X-----------?|-----?|-?|-?| | | Propose() | X--------?|-----?|-?|-?| | | Propose(ReadB) | | | | | | | | | | X------X-------------->|->| Accepted(N, . ) | | |<--------X--X-------->|->| Accepted(N, . ) | | | | | | | | | | | | | | | | !! Conflict detected, leader chooses | | | | | | | | commutative order: | | | | | | | | V =  | | | | | | | | | | X----->|->|->| | | Phase2Start(N+1,V) | | |<-----X- X- X-------->|->| Accepted(N+1,V) | | | | | | | | Stable =  . | | | | | | | |  | | | | | | | | | | | | | | | | !! More conflicting proposals X-----------?|-----?|-?|-?| | | Propose(WriteA) | X--------?|-----?|-?|-?| | | Propose(ReadA) | | | | | | | | | | X------X-------------->|->| Accepted(N+1, . ) | | |<--------X- X-------->|->| Accepted(N+1, . ) | | | | | | | | | | | | | | | | !! Leader chooses order: | | | | | | | | W =  | | | | | | | | | | X----->|->|->| | | Phase2Start(N+2,W) | | |<-----X- X- X-------->|->| Accepted(N+2,W) | | | | | | | | Stable =  . | | | | | | | |  . | | | | | | | |  | | | | | | | |

Спектакль

The above message flow shows us that Generalized Paxos can leverage operation semantics to avoid collisions when the spontaneous ordering of the network fails. This allows the protocol to be in practice quicker than Fast Paxos. However, when a collision occurs, Generalized Paxos needs two additional round trips to recover. This situation is illustrated with operations WriteB and ReadB in the above schema.

In the general case, such round trips are unavoidable and come from the fact that multiple commands can be accepted during a round. This makes the protocol more expensive than Paxos when conflicts are frequent. Hopefully two possible refinements of Generalized Paxos are possible to improve recovery time.^[21]

• First, if the coordinator is part of every quorum of acceptors (round N is said по центру), then to recover at round N+1 from a collision at round N, the coordinator skips phase 1 and proposes at phase 2 the sequence it accepted last during round N. This reduces the cost of recovery to a single round trip.
• Second, if both rounds N and N+1 use a unique and identical centered quorum, when an acceptor detects a collision at round N, it spontaneously proposes at round N+1 a sequence suffixing both (i) the sequence accepted at round N by the coordinator and (ii) the greatest non-conflicting prefix it accepted at round N. For instance, if the coordinator and the acceptor accepted respectively at round N and , the acceptor will spontaneously accept at round N+1. With this variation, the cost of recovery is a single message delay which is obviously optimal. Notice here that the use of a unique quorum at a round does not harm liveness. This comes from the fact that any process in this quorum is a read quorum for the prepare phase of the next rounds.^[22]

Византийский Паксос

Paxos may also be extended to support arbitrary failures of the participants, including lying, fabrication of messages, collusion with other participants, selective non-participation, etc. These types of failures are called Byzantine failures, after the solution popularized by Lamport.^[23]

Византийский Паксос^[24] introduced by Castro and Лисков adds an extra message (Verify) which acts to distribute knowledge and verify the actions of the other processors:

Message flow: Byzantine Multi-Paxos, steady state

Client   Proposer      Acceptor     Learner   | | | | | | | X-------->| | | | | | Request   | X--------->|->|->| | | Accept!(N,I,V)   | | X<>X<>X       | | Verify(N,I,V) - BROADCAST   | |<---------X--X--X------>|->| Accepted(N,V)   |<---------------------------------X--X  Response(V)   | | | | | | |

Fast Byzantine Paxos^[25] introduced by Martin and Alvisi removes this extra delay, since the client sends commands directly to the Acceptors.

Обратите внимание Принято message in Fast Byzantine Paxos is sent to all Acceptors and all Learners, while Fast Paxos sends Принято messages only to Learners):

Message flow: Fast Byzantine Multi-Paxos, steady state

Client    Acceptor     Learner   | | | | | | X----->|->|->| | | Accept!(N,I,V)   | X<>X<>X------>|->| Accepted(N,I,V) - BROADCAST   |<-------------------X--X  Response(V)   | | | | | |

The failure scenario is the same for both protocols; Each Learner waits to receive F+1 identical messages from different Acceptors. If this does not occur, the Acceptors themselves will also be aware of it (since they exchanged each other's messages in the broadcast round), and correct Acceptors will re-broadcast the agreed value:

Message flow: Fast Byzantine Multi-Paxos, failure

Client    Acceptor     Learner   | | | ! | | !! One Acceptor is faulty   X----->|->|->! | | Accept!(N,I,V)   | X<>X<>X------>|->| Accepted(N,I,{V,W}) - BROADCAST   | | | ! | | !! Learners receive 2 different commands   | | | ! | | !! Correct Acceptors notice error and choose   | X<>X<>X------>|->| Accepted(N,I,V) - BROADCAST   |<-------------------X--X  Response(V)   | | | ! | |

Adapting Paxos for RDMA networks

With the emergence of very high speed reliable datacenter networks that support remote DMA (RDMA ), there has been substantial interest in optimizing Paxos to leverage hardware offloading, in which the network interface card and network routers provide reliability and network-layer congestion control, freeing the host CPU for other tasks. В Derecho C++ Paxos library is an open-source Paxos implementation that explores this option^[12].

Derecho offers both a classic Paxos, with data durability across full shutdown/restart sequences, and vertical Paxos (atomic multicast), for in-memory replication and state-machine synchronization. The Paxos protocols employed by Derecho needed to be adapted to maximize asynchronous data streaming and remove other sources of delay on the leader's critical path. So doing enables Derecho to sustain the full bidirectional RDMA data rate. In contrast, although traditional Paxos protocols can be migrated to an RDMA network by simply mapping the message send operations to native RDMA operations, doing so leaves round-trip delays on the critical path. In high-speed RDMA networks, even small delays can be large enough to prevent utilization of the full potential bandwidth.

Production use of Paxos

Эта секция нужны дополнительные цитаты для проверка. Пожалуйста помоги улучшить эту статью к добавление цитат в надежные источники. Материал, не полученный от источника, может быть оспорен и удален Найдите источники: "Paxos" computer science  – Новости  · газеты  · книги  · ученый  · JSTOR (Октябрь 2018 г.) (Узнайте, как и когда удалить этот шаблон сообщения)

• Google uses the Paxos algorithm in their Chubby distributed lock service in order to keep replicas consistent in case of failure. Chubby is used by Большой стол which is now in production in Google Analytics and other products.
• Google Spanner and Megastore use the Paxos algorithm internally.
• В OpenReplica replication service uses Paxos to maintain replicas for an open access system that enables users to create fault-tolerant objects. It provides high performance through concurrent rounds and flexibility through dynamic membership changes.
• IBM supposedly uses the Paxos algorithm in their Контроллер тома IBM SAN product to implement a general purpose fault-tolerant virtual machine used to run the configuration and control components of the storage virtualization services offered by the cluster. (Original MIT & IBM research paper )
• Microsoft uses Paxos in the Autopilot cluster management service from Bing, and in Windows Server Failover Clustering.
• WANdisco have implemented Paxos within their DConE active-active replication technology.^[26]
• XtreemFS uses a Paxos-based арендовать negotiation algorithm for fault-tolerant and consistent replication of file data and metadata.^[27]
• Heroku uses Doozerd which implements Paxos for its consistent distributed data store.
• Ceph uses Paxos as part of the monitor processes to agree which OSDs are up and in the cluster.
• В Clustrix distributed SQL database uses Paxos for distributed transaction resolution.
• Neo4j HA graph database implements Paxos, replacing Apache ZooKeeper from v1.9
• Apache Cassandra NoSQL database uses Paxos for Light Weight Transaction feature only
• Amazon Elastic Container Services uses Paxos to maintain a consistent view of cluster state

Смотрите также

• Chandra–Toueg consensus algorithm
• State machine
• Плот

Рекомендации

внешняя ссылка

• Leslie Lamport's home page
• Paxos Made Simple
• Paxos Made Moderately Complex
• Revisiting the Paxos Algorithm
• Paxos Commit
• Google Whitepaper: Chubby Distributed Lock Service
• Google Whitepaper: Bigtable A Distributed Storage System for Structured Data
• Survey of Paxos Algorithms (2007)
• OpenReplica Open Replication Service
• FTFile: Fault Tolerant File library
• Isis2 library (the SafeSend primitive is a free, open source implementation of Paxos)
• Mencius - Circular rotating Paxos for geo-distributed systems
• WANdisco - Active-Active Replication solutions for Hadoop, Subversion & GIT
• libpaxos, a collection of open source implementations of the Paxos algorithm
• libpaxos-cpp, a C++ implementation of the paxos distributed consensus algorithm
• JBP - Java Byzantine Paxos
• erlpaxos, Paxos by Erlang
• paxos - Straight-forward paxos implementation in Python & Java
• Manhattan Paxos (mpaxos), Paxos in C, supporting multiple paxos groups and efficient transactions across them.
• Clustering with Neo4j
• HT-Paxos
• PaxosStore, paxos implementation in WeChat
• LWT in Cassandra