RabbitMQ ਦਾ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਸਹਿਜ ਪ੍ਰਵਾਸ

RabbitMQ Erlang ਵਿੱਚ ਲਿਖਿਆ ਇੱਕ ਸੁਨੇਹਾ ਬ੍ਰੋਕਰ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਮਲਟੀਪਲ ਨੋਡਾਂ ਵਿੱਚ ਪੂਰੇ ਡੇਟਾ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੇ ਨਾਲ ਇੱਕ ਫੇਲਓਵਰ ਕਲੱਸਟਰ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿੱਥੇ ਹਰੇਕ ਨੋਡ ਬੇਨਤੀਆਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਦੀ ਸੇਵਾ ਕਰ ਸਕਦਾ ਹੈ। ਪ੍ਰੋਡਕਸ਼ਨ ਓਪਰੇਸ਼ਨ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਹੋਣ ਕਰਕੇ, ਅਸੀਂ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ RabbitMQ ਸਥਾਪਨਾਵਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦੇ ਹਾਂ ਅਤੇ ਡਾਊਨਟਾਈਮ ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਕਲੱਸਟਰ ਤੋਂ ਦੂਜੇ ਕਲੱਸਟਰ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਮਾਈਗਰੇਟ ਕਰਨ ਦੀ ਲੋੜ ਦਾ ਸਾਹਮਣਾ ਕੀਤਾ ਗਿਆ ਸੀ।

ਸਾਨੂੰ ਘੱਟੋ-ਘੱਟ ਦੋ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਸ ਕਾਰਵਾਈ ਦੀ ਲੋੜ ਸੀ:

1. RabbitMQ ਕਲੱਸਟਰ ਤੋਂ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ ਜੋ ਕਿ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਸਥਿਤ ਨਹੀਂ ਹੈ - ਇੱਕ ਨਵੇਂ - ਪਹਿਲਾਂ ਹੀ "ਕੁਬਰਨੇਟਾਈਜ਼ਡ" (ਜਿਵੇਂ ਕਿ K8s ਪੌਡਾਂ ਵਿੱਚ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ) - ਕਲੱਸਟਰ ਵਿੱਚ।
2. ਕੁਬਰਨੇਟਸ ਦੇ ਅੰਦਰ RabbitMQ ਦਾ ਇੱਕ ਨੇਮਸਪੇਸ ਤੋਂ ਦੂਜੇ ਵਿੱਚ ਮਾਈਗਰੇਸ਼ਨ (ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਸਰਕਟਾਂ ਨੂੰ ਨੇਮਸਪੇਸ ਦੁਆਰਾ ਸੀਮਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇੱਕ ਸਰਕਟ ਤੋਂ ਦੂਜੇ ਸਰਕਟ ਵਿੱਚ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ)।

ਲੇਖ ਵਿੱਚ ਪ੍ਰਸਤਾਵਿਤ ਵਿਅੰਜਨ ਉਹਨਾਂ ਸਥਿਤੀਆਂ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ (ਪਰ ਉਹਨਾਂ ਤੱਕ ਹੀ ਸੀਮਿਤ ਨਹੀਂ ਹੈ) ਜਿਸ ਵਿੱਚ ਇੱਕ ਪੁਰਾਣਾ RabbitMQ ਕਲੱਸਟਰ ਹੈ (ਉਦਾਹਰਨ ਲਈ, 3 ਨੋਡਾਂ ਦਾ), ਜਾਂ ਤਾਂ ਪਹਿਲਾਂ ਹੀ K8s ਵਿੱਚ ਜਾਂ ਕੁਝ ਪੁਰਾਣੇ ਸਰਵਰਾਂ 'ਤੇ ਸਥਿਤ ਹੈ। ਕੁਬਰਨੇਟਸ (ਪਹਿਲਾਂ ਹੀ ਉੱਥੇ ਜਾਂ ਭਵਿੱਖ ਵਿੱਚ) ਉੱਤੇ ਹੋਸਟ ਕੀਤੀ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਇਸਦੇ ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ:

... ਅਤੇ ਸਾਨੂੰ ਇਸ ਨੂੰ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਨਵੇਂ ਉਤਪਾਦਨ ਵਿੱਚ ਮਾਈਗਰੇਟ ਕਰਨ ਦੇ ਕੰਮ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਰਿਹਾ ਹੈ।

ਪਹਿਲਾਂ, ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਈ ਆਮ ਪਹੁੰਚ ਦਾ ਵਰਣਨ ਕੀਤਾ ਜਾਵੇਗਾ, ਅਤੇ ਉਸ ਤੋਂ ਬਾਅਦ ਇਸਦੇ ਲਾਗੂ ਕਰਨ ਦੇ ਤਕਨੀਕੀ ਵੇਰਵਿਆਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਜਾਵੇਗਾ.

ਮਾਈਗ੍ਰੇਸ਼ਨ ਐਲਗੋਰਿਦਮ

ਪਹਿਲੀ, ਸ਼ੁਰੂਆਤੀ, ਕਿਸੇ ਵੀ ਕਾਰਵਾਈ ਤੋਂ ਪਹਿਲਾਂ ਪੜਾਅ ਇਹ ਜਾਂਚ ਕਰਨਾ ਹੈ ਕਿ ਪੁਰਾਣੀ RabbitMQ ਇੰਸਟਾਲੇਸ਼ਨ ਵਿੱਚ ਉੱਚ ਉਪਲਬਧਤਾ ਮੋਡ ਸਮਰੱਥ ਹੈ (HA). ਕਾਰਨ ਸਪੱਸ਼ਟ ਹੈ - ਅਸੀਂ ਕੋਈ ਡਾਟਾ ਗੁਆਉਣਾ ਨਹੀਂ ਚਾਹੁੰਦੇ। ਇਸ ਜਾਂਚ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ, ਤੁਸੀਂ RabbitMQ ਐਡਮਿਨ ਪੈਨਲ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ ਅਤੇ ਐਡਮਿਨ → ਪਾਲਿਸੀਆਂ ਟੈਬ ਵਿੱਚ ਇਹ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਮੁੱਲ ਸੈੱਟ ਹੈ। ha-mode: all:

ਅਗਲਾ ਕਦਮ ਕੁਬਰਨੇਟਸ ਪੌਡਜ਼ ਵਿੱਚ ਇੱਕ ਨਵਾਂ RabbitMQ ਕਲੱਸਟਰ ਬਣਾਉਣਾ ਹੈ (ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਉਦਾਹਰਨ ਲਈ, 3 ਨੋਡਾਂ ਵਾਲੇ, ਪਰ ਉਹਨਾਂ ਦੀ ਗਿਣਤੀ ਵੱਖਰੀ ਹੋ ਸਕਦੀ ਹੈ)।

ਇਸ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਪੁਰਾਣੇ ਅਤੇ ਨਵੇਂ RabbitMQ ਕਲੱਸਟਰਾਂ ਨੂੰ ਮਿਲਾਉਂਦੇ ਹਾਂ, ਇੱਕ ਸਿੰਗਲ ਕਲੱਸਟਰ (6 ਨੋਡਾਂ ਦਾ):

ਪੁਰਾਣੇ ਅਤੇ ਨਵੇਂ RabbitMQ ਕਲੱਸਟਰਾਂ ਵਿਚਕਾਰ ਡਾਟਾ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕੀਤੀ ਗਈ ਹੈ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਸਾਰਾ ਡੇਟਾ ਕਲੱਸਟਰ ਵਿੱਚ ਸਾਰੇ ਨੋਡਾਂ ਵਿਚਕਾਰ ਸਮਕਾਲੀ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਨਵੇਂ ਕਲੱਸਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹਾਂ:

ਇਹਨਾਂ ਓਪਰੇਸ਼ਨਾਂ ਤੋਂ ਬਾਅਦ, RabbitMQ ਕਲੱਸਟਰ ਤੋਂ ਪੁਰਾਣੇ ਨੋਡਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ ਕਾਫ਼ੀ ਹੈ, ਅਤੇ ਇਸ ਕਦਮ ਨੂੰ ਪੂਰਾ ਮੰਨਿਆ ਜਾ ਸਕਦਾ ਹੈ:

ਅਸੀਂ ਇਸ ਸਕੀਮ ਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਕਈ ਵਾਰ ਵਰਤਿਆ ਹੈ। ਹਾਲਾਂਕਿ, ਸਾਡੀ ਆਪਣੀ ਸਹੂਲਤ ਲਈ, ਅਸੀਂ ਇਸਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਪ੍ਰਣਾਲੀ ਦੇ ਅੰਦਰ ਲਾਗੂ ਕੀਤਾ ਹੈ ਜੋ ਕਈ ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰਾਂ ਵਿੱਚ ਮਿਆਰੀ RMQ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਵੰਡਦਾ ਹੈ। (ਉਨ੍ਹਾਂ ਲਈ ਜੋ ਉਤਸੁਕ ਹਨ: ਅਸੀਂ ਇਸ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ addon-operatorਜਿਸ ਬਾਰੇ ਅਸੀਂ ਹੁਣੇ ਹੁਣੇ ਦੱਸਿਆ). ਹੇਠਾਂ ਅਸੀਂ ਵਿਅਕਤੀਗਤ ਹਿਦਾਇਤਾਂ ਪੇਸ਼ ਕਰਾਂਗੇ ਜੋ ਕੋਈ ਵੀ ਪ੍ਰਸਤਾਵਿਤ ਹੱਲ ਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਅਜ਼ਮਾਉਣ ਲਈ ਆਪਣੀਆਂ ਸਥਾਪਨਾਵਾਂ 'ਤੇ ਲਾਗੂ ਕਰ ਸਕਦਾ ਹੈ।

ਆਓ ਇਸ ਨੂੰ ਅਭਿਆਸ ਵਿੱਚ ਅਜ਼ਮਾਈਏ

ਲੋੜ

ਵੇਰਵੇ ਬਹੁਤ ਸਧਾਰਨ ਹਨ:

1. Kubernetes ਕਲੱਸਟਰ (minikube ਵੀ ਕੰਮ ਕਰੇਗਾ);
2. RabbitMQ ਕਲੱਸਟਰ (ਬੇਅਰ ਮੈਟਲ 'ਤੇ ਤਾਇਨਾਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਅਧਿਕਾਰਤ ਹੈਲਮ ਚਾਰਟ ਤੋਂ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਇੱਕ ਨਿਯਮਤ ਕਲੱਸਟਰ ਵਾਂਗ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ)।

ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ ਲਈ, ਮੈਂ ਕੁਬਰਨੇਟਸ ਨੂੰ RMQ ਤੈਨਾਤ ਕੀਤਾ ਅਤੇ ਇਸਨੂੰ ਬੁਲਾਇਆ rmq-old.

ਤਿਆਰ ਰਹੋ

1. ਹੈਲਮ ਚਾਰਟ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਥੋੜਾ ਜਿਹਾ ਸੰਪਾਦਿਤ ਕਰੋ:

helm fetch --untar stable/rabbitmq-ha

ਸਹੂਲਤ ਲਈ, ਅਸੀਂ ਇੱਕ ਪਾਸਵਰਡ ਸੈਟ ਕਰਦੇ ਹਾਂ, ErlangCookie ਅਤੇ ਰਾਜਨੀਤੀ ਕਰੋ ha-allਤਾਂ ਕਿ ਮੂਲ ਰੂਪ ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ RMQ ਕਲੱਸਟਰ ਦੇ ਸਾਰੇ ਨੋਡਾਂ ਵਿਚਕਾਰ ਸਮਕਾਲੀ ਕੀਤਾ ਜਾਵੇ:

rabbitmqPassword: guest
rabbitmqErlangCookie: mae9joopaol7aiVu3eechei2waiGa2we
definitions:
policies: |-
  {
    "name": "ha-all",
    "pattern": ".*",
    "vhost": "/",
    "definition": {
      "ha-mode": "all",
      "ha-sync-mode": "automatic",
      "ha-sync-batch-size": 81920
    }
  }

2. ਚਾਰਟ ਸਥਾਪਿਤ ਕਰੋ:

helm install . --name rmq-old --namespace rmq-old

3. RabbitMQ ਐਡਮਿਨ ਪੈਨਲ 'ਤੇ ਜਾਓ, ਇੱਕ ਨਵੀਂ ਕਤਾਰ ਬਣਾਓ ਅਤੇ ਕਈ ਸੁਨੇਹੇ ਸ਼ਾਮਲ ਕਰੋ। ਉਹਨਾਂ ਦੀ ਲੋੜ ਹੋਵੇਗੀ ਤਾਂ ਜੋ ਮਾਈਗ੍ਰੇਸ਼ਨ ਤੋਂ ਬਾਅਦ ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕੀਏ ਕਿ ਸਾਰਾ ਡਾਟਾ ਸੁਰੱਖਿਅਤ ਹੈ ਅਤੇ ਅਸੀਂ ਕੁਝ ਵੀ ਨਹੀਂ ਗੁਆਇਆ ਹੈ:

ਟੈਸਟ ਬੈਂਚ ਤਿਆਰ ਹੈ: ਸਾਡੇ ਕੋਲ ਡੇਟਾ ਵਾਲਾ "ਪੁਰਾਣਾ" RabbitMQ ਹੈ ਜਿਸ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।

RabbitMQ ਕਲੱਸਟਰ ਨੂੰ ਮਾਈਗ੍ਰੇਟ ਕਰਨਾ

1. ਪਹਿਲਾਂ, ਆਓ ਨਵੇਂ RabbitMQ ਨੂੰ ਇਸ ਵਿੱਚ ਲਾਗੂ ਕਰੀਏ ਦੋਸਤ ਨਾਮ ਸਥਾਨ ਦੇ ਨਾਲ ਉਹੀ ErlangCookie ਅਤੇ ਉਪਭੋਗਤਾ ਲਈ ਪਾਸਵਰਡ. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਉੱਪਰ ਦੱਸੇ ਗਏ ਓਪਰੇਸ਼ਨ ਕਰਾਂਗੇ, RMQ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਅੰਤਮ ਕਮਾਂਡ ਨੂੰ ਹੇਠਾਂ ਬਦਲ ਕੇ:

helm install . --name rmq-new --namespace rmq-new

2. ਹੁਣ ਤੁਹਾਨੂੰ ਨਵੇਂ ਕਲੱਸਟਰ ਨੂੰ ਪੁਰਾਣੇ ਨਾਲ ਮਿਲਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਹਰ ਇੱਕ ਪੌਡ 'ਤੇ ਜਾਓ ਨਵ RabbitMQ ਅਤੇ ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾਓ:

export OLD_RMQ=rabbit@rmq-old-rabbitmq-ha-0.rmq-old-rabbitmq-ha-discovery.rmq-old.svc.cluster.local && 
  rabbitmqctl stop_app && 
  rabbitmqctl join_cluster $OLD_RMQ && 
  rabbitmqctl start_app

ਇੱਕ ਵੇਰੀਏਬਲ ਵਿੱਚ OLD_RMQ ਨੋਡਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦਾ ਪਤਾ ਮਿਲਦਾ ਹੈ ਪੁਰਾਣਾ RMQ ਕਲੱਸਟਰ।

ਇਹ ਕਮਾਂਡਾਂ ਮੌਜੂਦਾ ਨੋਡ ਨੂੰ ਰੋਕ ਦੇਣਗੀਆਂ ਨਵ RMQ ਕਲੱਸਟਰ, ਇਸਨੂੰ ਪੁਰਾਣੇ ਕਲੱਸਟਰ ਨਾਲ ਜੋੜੋ ਅਤੇ ਇਸਨੂੰ ਦੁਬਾਰਾ ਲਾਂਚ ਕਰੋ।

3. 6 ਨੋਡਾਂ ਦਾ RMQ ਕਲੱਸਟਰ ਤਿਆਰ ਹੈ:

ਤੁਹਾਨੂੰ ਸਭ ਨੋਡਾਂ ਵਿਚਕਾਰ ਸੁਨੇਹੇ ਸਮਕਾਲੀ ਹੋਣ ਤੱਕ ਉਡੀਕ ਕਰਨੀ ਪਵੇਗੀ। ਇਹ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ ਕਿ ਸੁਨੇਹਾ ਸਮਕਾਲੀਕਰਨ ਸਮਾਂ ਹਾਰਡਵੇਅਰ ਦੀ ਸਮਰੱਥਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਜਿਸ 'ਤੇ ਕਲੱਸਟਰ ਤਾਇਨਾਤ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਸੁਨੇਹਿਆਂ ਦੀ ਸੰਖਿਆ 'ਤੇ। ਵਰਣਿਤ ਦ੍ਰਿਸ਼ ਵਿੱਚ, ਉਹਨਾਂ ਵਿੱਚੋਂ ਸਿਰਫ 10 ਹਨ, ਇਸਲਈ ਡੇਟਾ ਨੂੰ ਤੁਰੰਤ ਸਮਕਾਲੀ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ ਸੁਨੇਹਿਆਂ ਦੀ ਕਾਫ਼ੀ ਵੱਡੀ ਸੰਖਿਆ ਦੇ ਨਾਲ, ਸਮਕਾਲੀਕਰਨ ਘੰਟਿਆਂ ਤੱਕ ਰਹਿ ਸਕਦਾ ਹੈ।

ਇਸ ਲਈ, ਸਮਕਾਲੀ ਸਥਿਤੀ:

ਇਹ ਇਸ ਲਈ ਹੈ +5 ਮਤਲਬ ਸੁਨੇਹੇ ਪਹਿਲਾਂ ਹੀ ਅੰਦਰ ਹਨ ਹੋਰ 5 ਨੋਡਾਂ 'ਤੇ (ਫੀਲਡ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਨੂੰ ਛੱਡ ਕੇ Node). ਇਸ ਤਰ੍ਹਾਂ, ਸਮਕਾਲੀਕਰਨ ਸਫਲ ਰਿਹਾ।

4. ਸਭ ਕੁਝ ਬਚਦਾ ਹੈ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ RMQ ਐਡਰੈੱਸ ਨੂੰ ਨਵੇਂ ਕਲੱਸਟਰ ਵਿੱਚ ਬਦਲਣਾ (ਇੱਥੇ ਖਾਸ ਕਾਰਵਾਈਆਂ ਤੁਹਾਡੇ ਦੁਆਰਾ ਵਰਤੇ ਜਾ ਰਹੇ ਤਕਨਾਲੋਜੀ ਸਟੈਕ ਅਤੇ ਹੋਰ ਐਪਲੀਕੇਸ਼ਨ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀਆਂ ਹਨ), ਜਿਸ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਪੁਰਾਣੇ ਨੂੰ ਅਲਵਿਦਾ ਕਹਿ ਸਕਦੇ ਹੋ।

ਆਖਰੀ ਓਪਰੇਸ਼ਨ ਲਈ (ਅਰਥਾਤ ਪਹਿਲਾਂ ਹੀ после ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਨਵੇਂ ਕਲੱਸਟਰ ਵਿੱਚ ਬਦਲਣਾ) ਹਰੇਕ ਨੋਡ 'ਤੇ ਜਾਓ ਪੁਰਾਣਾ ਕਮਾਂਡਾਂ ਨੂੰ ਕਲੱਸਟਰ ਕਰੋ ਅਤੇ ਚਲਾਓ:

rabbitmqctl stop_app
rabbitmqctl reset

ਪੁਰਾਣੇ ਨੋਡਸ ਬਾਰੇ ਕਲੱਸਟਰ “ਭੁੱਲ ਗਿਆ”: ਤੁਸੀਂ ਪੁਰਾਣੇ RMQ ਨੂੰ ਮਿਟਾ ਸਕਦੇ ਹੋ, ਜਿਸ ਸਮੇਂ ਮੂਵ ਪੂਰਾ ਹੋ ਜਾਵੇਗਾ।

ਟਿੱਪਣੀ: ਜੇਕਰ ਤੁਸੀਂ ਸਰਟੀਫਿਕੇਟਾਂ ਦੇ ਨਾਲ RMQ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਕੁਝ ਵੀ ਨਹੀਂ ਬਦਲਦਾ - ਚਲਦੀ ਪ੍ਰਕਿਰਿਆ ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਕੀਤੀ ਜਾਵੇਗੀ।

ਸਿੱਟਾ

ਵਰਣਿਤ ਸਕੀਮ ਲਗਭਗ ਸਾਰੇ ਮਾਮਲਿਆਂ ਲਈ ਢੁਕਵੀਂ ਹੈ ਜਦੋਂ ਸਾਨੂੰ RabbitMQ ਨੂੰ ਮਾਈਗ੍ਰੇਟ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਾਂ ਸਿਰਫ਼ ਇੱਕ ਨਵੇਂ ਕਲੱਸਟਰ ਵਿੱਚ ਜਾਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਮੁਸ਼ਕਲਾਂ ਕੇਵਲ ਇੱਕ ਵਾਰ ਹੀ ਪੈਦਾ ਹੋਈਆਂ, ਜਦੋਂ RMQ ਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਥਾਵਾਂ ਤੋਂ ਐਕਸੈਸ ਕੀਤਾ ਗਿਆ ਸੀ, ਅਤੇ ਸਾਡੇ ਕੋਲ ਹਰ ਜਗ੍ਹਾ RMQ ਪਤੇ ਨੂੰ ਇੱਕ ਨਵੇਂ ਵਿੱਚ ਬਦਲਣ ਦਾ ਮੌਕਾ ਨਹੀਂ ਸੀ। ਫਿਰ ਅਸੀਂ ਉਸੇ ਨੇਮਸਪੇਸ ਵਿੱਚ ਉਸੇ ਲੇਬਲਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵਾਂ RMQ ਲਾਂਚ ਕੀਤਾ ਤਾਂ ਜੋ ਇਹ ਮੌਜੂਦਾ ਸੇਵਾਵਾਂ ਅਤੇ ਦਾਖਲੇ ਦੇ ਅਧੀਨ ਆਵੇ, ਅਤੇ ਪੌਡ ਨੂੰ ਲਾਂਚ ਕਰਨ ਵੇਲੇ ਅਸੀਂ ਹੱਥਾਂ ਨਾਲ ਲੇਬਲਾਂ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕੀਤਾ, ਉਹਨਾਂ ਨੂੰ ਸ਼ੁਰੂ ਵਿੱਚ ਹਟਾ ਦਿੱਤਾ ਤਾਂ ਕਿ ਬੇਨਤੀਆਂ 'ਤੇ ਨਾ ਆਉਣ। ਖਾਲੀ RMQ, ਅਤੇ ਸੁਨੇਹਿਆਂ ਦੇ ਸਮਕਾਲੀ ਹੋਣ ਤੋਂ ਬਾਅਦ ਉਹਨਾਂ ਨੂੰ ਵਾਪਸ ਜੋੜਨਾ।

ਅਸੀਂ ਬਦਲੀ ਹੋਈ ਸੰਰਚਨਾ ਦੇ ਨਾਲ RabbitMQ ਨੂੰ ਇੱਕ ਨਵੇਂ ਸੰਸਕਰਣ ਵਿੱਚ ਅੱਪਡੇਟ ਕਰਨ ਵੇਲੇ ਉਹੀ ਰਣਨੀਤੀ ਵਰਤੀ - ਹਰ ਚੀਜ਼ ਇੱਕ ਘੜੀ ਵਾਂਗ ਕੰਮ ਕਰਦੀ ਸੀ।

PS

ਇਸ ਸਮੱਗਰੀ ਦੀ ਤਰਕਪੂਰਨ ਨਿਰੰਤਰਤਾ ਵਜੋਂ, ਅਸੀਂ MongoDB (ਇੱਕ ਹਾਰਡਵੇਅਰ ਸਰਵਰ ਤੋਂ Kubernetes ਵਿੱਚ ਮਾਈਗ੍ਰੇਸ਼ਨ) ਅਤੇ MySQL (ਅਸੀਂ Kubernetes ਦੇ ਅੰਦਰ ਇਸ DBMS ਨੂੰ ਕਿਵੇਂ ਤਿਆਰ ਕਰਦੇ ਹਾਂ) ਬਾਰੇ ਲੇਖ ਤਿਆਰ ਕਰ ਰਹੇ ਹਾਂ। ਉਹ ਆਉਣ ਵਾਲੇ ਮਹੀਨਿਆਂ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੇ ਜਾਣਗੇ।

Pps

ਸਾਡੇ ਬਲੌਗ 'ਤੇ ਵੀ ਪੜ੍ਹੋ:

• «ਡਾਟਾਬੇਸ ਅਤੇ ਕੁਬਰਨੇਟਸ (ਸਮੀਖਿਆ ਅਤੇ ਵੀਡੀਓ ਰਿਪੋਰਟ)";
• «K8s ਟਿਪਸ ਅਤੇ ਟ੍ਰਿਕਸ: ਵੱਡੇ ਡੇਟਾਬੇਸ ਲਈ ਬੂਟਸਟਰੈਪ ਨੂੰ ਤੇਜ਼ ਕਰਨਾ".

ਸਰੋਤ: www.habr.com