ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ ਡਿਪਲਾਇਮੈਂਟ ਅਤੇ ਡਾਟਾਬੇਸ

ਇਹ ਲੇਖ ਵਿਸਥਾਰ ਵਿੱਚ ਦੱਸਦਾ ਹੈ ਕਿ ਤੈਨਾਤੀ ਵਿੱਚ ਡੇਟਾਬੇਸ ਅਨੁਕੂਲਤਾ ਮੁੱਦਿਆਂ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕਰਨਾ ਹੈ। ਅਸੀਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗੇ ਕਿ ਤੁਹਾਡੀਆਂ ਪ੍ਰੋਡਕਸ਼ਨ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦਾ ਕੀ ਹੋ ਸਕਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਮੁੱਢਲੀ ਤਿਆਰੀ ਤੋਂ ਬਿਨਾਂ ਤੈਨਾਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ। ਫਿਰ ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਲਾਈਫਸਾਈਕਲ ਪੜਾਵਾਂ ਵਿੱਚੋਂ ਲੰਘਾਂਗੇ ਜੋ ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ (ਲਗਭਗ ਲੇਨ: ਅੱਗੇ - ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ). ਸਾਡੇ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਨਤੀਜਾ ਬੈਕਵਰਡ-ਅਸੰਗਤ ਡੇਟਾਬੇਸ ਤਬਦੀਲੀ ਨੂੰ ਬੈਕਵਰਡ-ਅਨੁਕੂਲ ਤਰੀਕੇ ਨਾਲ ਲਾਗੂ ਕਰਨਾ ਹੋਵੇਗਾ।

ਜੇਕਰ ਤੁਸੀਂ ਲੇਖ ਤੋਂ ਕੋਡ ਉਦਾਹਰਨਾਂ ਨੂੰ ਸਮਝਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਇੱਥੇ ਲੱਭ ਸਕਦੇ ਹੋ GitHub.

ਜਾਣ ਪਛਾਣ

ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ ਤੈਨਾਤੀ

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

ਇਸ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ? ਇੱਥੇ ਕਈ ਤਰੀਕੇ ਹਨ, ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇਹ ਹੈ:

• ਤੁਹਾਡੀ ਸੇਵਾ ਦਾ ਸੰਸਕਰਣ ਨੰਬਰ 1 ਤੈਨਾਤ ਕਰੋ
• ਇੱਕ ਡਾਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕਰੋ
• ਸੰਸਕਰਣ #2 ਦੇ ਸਮਾਨਾਂਤਰ ਆਪਣੀ ਸੇਵਾ ਦੇ ਸੰਸਕਰਣ #1 ਨੂੰ ਤੈਨਾਤ ਕਰੋ
• ਜਿਵੇਂ ਹੀ ਤੁਸੀਂ ਦੇਖਦੇ ਹੋ ਕਿ ਸੰਸਕਰਣ ਨੰਬਰ 2 ਕੰਮ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇਹ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਸੰਸਕਰਣ ਨੰ. 1 ਨੂੰ ਹਟਾ ਦਿਓ
• ਤਿਆਰ ਹੈ!

ਆਸਾਨ, ਹੈ ਨਾ? ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇਹ ਇੰਨਾ ਸੌਖਾ ਨਹੀਂ ਹੈ, ਅਤੇ ਅਸੀਂ ਇਸਨੂੰ ਬਾਅਦ ਵਿੱਚ ਵਿਸਥਾਰ ਵਿੱਚ ਦੇਖਾਂਗੇ। ਆਉ ਹੁਣ ਇੱਕ ਹੋਰ ਕਾਫ਼ੀ ਆਮ ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਜਾਂਚ ਕਰੀਏ - blue green deployment.

ਕੀ ਤੁਸੀਂ ਕਦੇ ਇਸ ਬਾਰੇ ਸੁਣਿਆ ਹੈ ਨੀਲੇ ਹਰੇ ਤੈਨਾਤੀ? ਕਲਾਉਡ ਫਾਊਂਡਰੀ ਇਸ ਨੂੰ ਬਹੁਤ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਜ਼ਰਾ ਦੇਖੋ ਇਹ ਲੇਖ, ਜਿੱਥੇ ਅਸੀਂ ਇਸ ਦਾ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵਰਣਨ ਕਰਦੇ ਹਾਂ। ਸੰਖੇਪ ਵਿੱਚ ਸੰਖੇਪ ਕਰਨ ਲਈ, ਆਓ ਅਸੀਂ ਤੁਹਾਨੂੰ ਯਾਦ ਦਿਵਾਉਂਦੇ ਹਾਂ ਕਿ ਨੀਲੇ ਹਰੇ ਤੈਨਾਤੀ ਨੂੰ ਕਿਵੇਂ ਕਰਨਾ ਹੈ:

• ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡੇ ਉਤਪਾਦਨ ਕੋਡ ਦੀਆਂ ਦੋ ਕਾਪੀਆਂ ("ਨੀਲਾ" ਅਤੇ "ਹਰਾ") ਕੰਮ ਕਰਦੀਆਂ ਹਨ;
• ਸਾਰੇ ਟ੍ਰੈਫਿਕ ਨੂੰ ਨੀਲੇ ਵਾਤਾਵਰਣ ਵੱਲ ਭੇਜੋ, ਜਿਵੇਂ ਕਿ ਤਾਂ ਕਿ ਉਤਪਾਦਨ URL ਉੱਥੇ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹਨ;
• ਇੱਕ ਹਰੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਸਾਰੀਆਂ ਐਪਲੀਕੇਸ਼ਨ ਤਬਦੀਲੀਆਂ ਦੀ ਤਾਇਨਾਤੀ ਅਤੇ ਜਾਂਚ ਕਰੋ;
• ਯੂਆਰਐਲ ਨੂੰ ਨੀਲੇ ਤੋਂ ਹਰੇ ਵਾਤਾਵਰਨ ਵਿੱਚ ਬਦਲੋ

ਬਲੂ ਗ੍ਰੀਨ ਡਿਪਲਾਇਮੈਂਟ ਇੱਕ ਅਜਿਹੀ ਪਹੁੰਚ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਉਤਪਾਦਨ ਤੋੜਨ ਦੀ ਚਿੰਤਾ ਕੀਤੇ ਬਿਨਾਂ ਆਸਾਨੀ ਨਾਲ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪੇਸ਼ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਇਹ ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਹੈ ਕਿ ਭਾਵੇਂ ਕੁਝ ਵਾਪਰਦਾ ਹੈ, ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ "ਇੱਕ ਸਵਿੱਚ ਫਲਿੱਕ" ਕਰਕੇ ਪਿਛਲੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਵਾਪਸ ਆ ਸਕਦੇ ਹੋ।

ਉਪਰੋਕਤ ਸਭ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਇਹ ਸਵਾਲ ਪੁੱਛ ਸਕਦੇ ਹੋ: ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ ਦਾ ਬਲੂ ਗ੍ਰੀਨ ਡਿਪਲਾਇਮੈਂਟ ਨਾਲ ਕੀ ਸਬੰਧ ਹੈ?

ਖੈਰ, ਉਹਨਾਂ ਵਿੱਚ ਬਹੁਤ ਕੁਝ ਸਾਂਝਾ ਹੈ, ਕਿਉਂਕਿ ਇੱਕੋ ਵਾਤਾਵਰਣ ਦੀਆਂ ਦੋ ਕਾਪੀਆਂ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਉਹਨਾਂ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਦੁੱਗਣੀ ਕੋਸ਼ਿਸ਼ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਲਈ ਕੁਝ ਟੀਮਾਂ ਦਾਅਵਾ ਕਰਦੀਆਂ ਹਨ ਮਾਰਟਿਨ ਫੋਲਰ, ਇਸ ਪਹੁੰਚ ਦੀ ਇੱਕ ਪਰਿਵਰਤਨ ਦੀ ਪਾਲਣਾ ਕਰੋ:

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

ਅਤੇ ਇੱਥੇ ਅਸੀਂ ਇਸ ਲੇਖ ਵਿੱਚ ਮੁੱਖ ਸਮੱਸਿਆ ਵੱਲ ਆਉਂਦੇ ਹਾਂ. ਡਾਟਾਬੇਸ. ਆਉ ਇਸ ਵਾਕੰਸ਼ ਉੱਤੇ ਇੱਕ ਹੋਰ ਨਜ਼ਰ ਮਾਰੀਏ।

ਇੱਕ ਡਾਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕਰੋ.

ਹੁਣ ਤੁਹਾਨੂੰ ਆਪਣੇ ਆਪ ਤੋਂ ਇਹ ਸਵਾਲ ਪੁੱਛਣਾ ਪਏਗਾ - ਜੇ ਡੇਟਾਬੇਸ ਤਬਦੀਲੀ ਪਿੱਛੇ ਵੱਲ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ ਤਾਂ ਕੀ ਹੋਵੇਗਾ? ਕੀ ਐਪ ਦਾ ਮੇਰਾ ਪਹਿਲਾ ਸੰਸਕਰਣ ਬਰੇਕ ਨਹੀਂ ਹੋਵੇਗਾ? ਵਾਸਤਵ ਵਿੱਚ, ਇਹ ਬਿਲਕੁਲ ਅਜਿਹਾ ਹੀ ਹੋਵੇਗਾ ...

ਇਸ ਲਈ, ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ/ਨੀਲੇ ਹਰੇ ਤੈਨਾਤੀ ਦੇ ਵੱਡੇ ਲਾਭਾਂ ਦੇ ਨਾਲ, ਕੰਪਨੀਆਂ ਆਪਣੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਲਈ ਹੇਠਾਂ ਦਿੱਤੀ ਸੁਰੱਖਿਅਤ ਪ੍ਰਕਿਰਿਆ ਦੀ ਪਾਲਣਾ ਕਰਦੀਆਂ ਹਨ:

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

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

ਡਾਟਾਬੇਸ ਮੁੱਦੇ

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

ਵਰਜਨਿੰਗ ਸਕੀਮ

ਇਸ ਲੇਖ ਵਿਚ ਅਸੀਂ ਵਰਤਾਂਗੇ ਫਲਾਈਵੇਅ ਇੱਕ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਸਾਧਨ ਵਜੋਂ (ਲਗਭਗ ਅਨੁਵਾਦ: ਅਸੀਂ ਡੇਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਬਾਰੇ ਗੱਲ ਕਰ ਰਹੇ ਹਾਂ). ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਇੱਕ ਸਪਰਿੰਗ ਬੂਟ ਐਪਲੀਕੇਸ਼ਨ ਵੀ ਲਿਖਾਂਗੇ ਜਿਸ ਵਿੱਚ ਬਿਲਟ-ਇਨ ਫਲਾਈਵੇ ਸਪੋਰਟ ਹੈ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਸੰਦਰਭ ਸੈਟ ਅਪ ਕਰਦੇ ਸਮੇਂ ਸਕੀਮਾ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕਰੇਗਾ। ਫਲਾਈਵੇਅ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਵਿੱਚ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹੋ (ਮੂਲ ਰੂਪ ਵਿੱਚ classpath:db/migration). ਇੱਥੇ ਤੁਸੀਂ ਅਜਿਹੀਆਂ ਮਾਈਗ੍ਰੇਸ਼ਨ ਫਾਈਲਾਂ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਦੇਖ ਸਕਦੇ ਹੋ

└── db
 └── migration
     ├── V1__init.sql
     ├── V2__Add_surname.sql
     ├── V3__Final_migration.sql
     └── V4__Remove_lastname.sql

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਅਸੀਂ 4 ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟਾਂ ਵੇਖਦੇ ਹਾਂ ਜੋ, ਜੇਕਰ ਪਹਿਲਾਂ ਨਹੀਂ ਚਲਾਈਆਂ ਗਈਆਂ ਸਨ, ਐਪਲੀਕੇਸ਼ਨ ਸ਼ੁਰੂ ਹੋਣ 'ਤੇ ਇੱਕ ਤੋਂ ਬਾਅਦ ਇੱਕ ਚਲਾਈਆਂ ਜਾਣਗੀਆਂ। ਆਉ ਇੱਕ ਫਾਈਲ ਨੂੰ ਵੇਖੀਏ (V1__init.sql) ਇੱਕ ਉਦਾਹਰਣ ਵਜੋਂ.

CREATE TABLE PERSON (
id BIGINT GENERATED BY DEFAULT AS IDENTITY,
first_name varchar(255) not null,
last_name varchar(255) not null
);

insert into PERSON (first_name, last_name) values ('Dave', 'Syer');

ਹਰ ਚੀਜ਼ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਵੈ-ਵਿਆਖਿਆਤਮਕ ਹੈ: ਤੁਸੀਂ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ SQL ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਨੂੰ ਕਿਵੇਂ ਸੋਧਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਸਪਰਿੰਗ ਬੂਟ ਅਤੇ ਫਲਾਈਵੇ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, ਚੈੱਕ ਆਊਟ ਕਰੋ ਸਪਰਿੰਗ ਬੂਟ ਡੌਕਸ.

ਸਪਰਿੰਗ ਬੂਟ ਦੇ ਨਾਲ ਇੱਕ ਸਰੋਤ ਨਿਯੰਤਰਣ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਹਾਨੂੰ 2 ਵੱਡੇ ਲਾਭ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ:

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

ਡਾਟਾਬੇਸ ਸਮੱਸਿਆਵਾਂ ਦਾ ਨਿਪਟਾਰਾ ਕਰਨਾ

ਲੇਖ ਦੇ ਅਗਲੇ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਡੇਟਾਬੇਸ ਤਬਦੀਲੀਆਂ ਲਈ ਦੋ ਪਹੁੰਚਾਂ ਨੂੰ ਦੇਖਣ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਾਂਗੇ।

• ਪਿਛਲਾ ਅਸੰਗਤਤਾ
• ਪਿੱਛੇ ਅਨੁਕੂਲਤਾ

ਪਹਿਲੀ ਨੂੰ ਇੱਕ ਚੇਤਾਵਨੀ ਵਜੋਂ ਮੰਨਿਆ ਜਾਵੇਗਾ ਕਿ ਤੁਹਾਨੂੰ ਮੁੱਢਲੀ ਤਿਆਰੀ ਤੋਂ ਬਿਨਾਂ ਜ਼ੀਰੋ ਡਾਊਨਟਾਈਮ ਤੈਨਾਤੀ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ... ਦੂਜਾ ਇੱਕ ਹੱਲ ਪੇਸ਼ ਕਰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਬਿਨਾਂ ਡਾਊਨਟਾਈਮ ਦੇ ਤੈਨਾਤੀ ਕਿਵੇਂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਉਸੇ ਸਮੇਂ ਪਿਛੜੇ ਅਨੁਕੂਲਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖ ਸਕਦੇ ਹੋ।

ਸਾਡਾ ਪ੍ਰੋਜੈਕਟ ਜਿਸ 'ਤੇ ਅਸੀਂ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ ਉਹ ਇੱਕ ਸਧਾਰਨ ਸਪਰਿੰਗ ਬੂਟ ਫਲਾਈਵੇ ਐਪਲੀਕੇਸ਼ਨ ਹੋਵੇਗੀ ਜਿਸ ਵਿੱਚ ਹੈ Person с first_name и last_name ਡਾਟਾਬੇਸ ਵਿੱਚ (ਲਗਭਗ ਅਨੁਵਾਦ: Person ਇੱਕ ਸਾਰਣੀ ਹੈ ਅਤੇ first_name и last_name - ਇਹ ਇਸ ਵਿੱਚ ਖੇਤਰ ਹਨ). ਅਸੀਂ ਨਾਮ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹਾਂ last_name в surname.

ਧਾਰਨਾਵਾਂ

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

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

ਡਾਟਾਬੇਸ ਨੂੰ ਰੋਲਬੈਕ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ

ਇਹ ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ (ਕੁਝ ਡਾਟਾਬੇਸ ਰੋਲਬੈਕ ਲਗਭਗ ਅਸੰਭਵ ਹਨ, ਜਿਵੇਂ ਕਿ ਮਿਟਾਉਣਾ ਰੋਲਬੈਕ)। ਅਸੀਂ ਸਿਰਫ਼ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਾਪਸ ਲਿਆਉਣ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹਾਂ। ਇਸ ਤਰ੍ਹਾਂ, ਭਾਵੇਂ ਤੁਹਾਡੇ ਕੋਲ ਵੱਖਰੇ ਡੇਟਾਬੇਸ ਹਨ (ਉਦਾਹਰਨ ਲਈ, SQL ਅਤੇ NoSQL), ਤੁਹਾਡੀ ਤੈਨਾਤੀ ਪਾਈਪਲਾਈਨ ਇੱਕੋ ਜਿਹੀ ਦਿਖਾਈ ਦੇਵੇਗੀ।

ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਇੱਕ ਵਰਜਨ ਬੈਕ ਰੋਲ ਬੈਕ ਕਰਨਾ ਹਮੇਸ਼ਾ ਸੰਭਵ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (ਹੋਰ ਨਹੀਂ)

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

ਨੋਟ. ਵਧੇਰੇ ਪੜ੍ਹਨਯੋਗਤਾ ਲਈ, ਇਸ ਲੇਖ ਵਿੱਚ ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਮੁੱਖ ਸੰਸਕਰਣ ਨੂੰ ਬਦਲਾਂਗੇ।

ਕਦਮ 1: ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ

ਐਪ ਦਾ ਸੰਸਕਰਣ: 1.0.0
DB ਸੰਸਕਰਣ: v1

ਟਿੱਪਣੀ

ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ ਹੋਵੇਗੀ।

ਡਾਟਾਬੇਸ ਤਬਦੀਲੀਆਂ

DB ਸ਼ਾਮਿਲ ਹੈ last_name.

CREATE TABLE PERSON (
id BIGINT GENERATED BY DEFAULT AS IDENTITY,
first_name varchar(255) not null,
last_name varchar(255) not null
);

insert into PERSON (first_name, last_name) values ('Dave', 'Syer');

ਕੋਡ ਬਦਲਦਾ ਹੈ

ਐਪਲੀਕੇਸ਼ਨ ਵਿਅਕਤੀਗਤ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਦੀ ਹੈ last_name:

/*
 * Copyright 2012-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package sample.flyway;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Person {
    @Id
    @GeneratedValue
    private Long id;
    private String firstName;
    private String lastName;

    public String getFirstName() {
        return this.firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return this.lastName;
    }

    public void setLastName(String lastname) {
        this.lastName = lastname;
    }

    @Override
    public String toString() {
        return "Person [firstName=" + this.firstName + ", lastName=" + this.lastName
                + "]";
    }
}

ਪਿੱਛੇ ਵੱਲ ਅਸੰਗਤ ਕਾਲਮ ਦਾ ਨਾਮ ਬਦਲਣਾ

ਆਉ ਇੱਕ ਕਾਲਮ ਨਾਮ ਨੂੰ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਵੇਖੀਏ:

ਧਿਆਨ. ਹੇਠ ਦਿੱਤੀ ਉਦਾਹਰਣ ਜਾਣਬੁੱਝ ਕੇ ਚੀਜ਼ਾਂ ਨੂੰ ਤੋੜ ਦੇਵੇਗੀ। ਅਸੀਂ ਇਸਨੂੰ ਡੇਟਾਬੇਸ ਅਨੁਕੂਲਤਾ ਦੀ ਸਮੱਸਿਆ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਨ ਲਈ ਦਿਖਾਉਂਦੇ ਹਾਂ।

ਐਪ ਦਾ ਸੰਸਕਰਣ: 2.0.0.BAD

DB ਸੰਸਕਰਣ: v2bad

ਟਿੱਪਣੀ

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

A/B ਟੈਸਟਿੰਗ

ਮੌਜੂਦਾ ਸਥਿਤੀ ਇਹ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਹੈ 1.0.0, ਉਤਪਾਦਨ, ਅਤੇ ਡਾਟਾਬੇਸ ਵਿੱਚ ਤੈਨਾਤ v1. ਸਾਨੂੰ ਐਪਲੀਕੇਸ਼ਨ, ਸੰਸਕਰਣ ਦੀ ਦੂਜੀ ਉਦਾਹਰਣ ਨੂੰ ਤੈਨਾਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ 2.0.0.BAD, ਅਤੇ ਡਾਟਾਬੇਸ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ v2bad.

ਕਦਮ:

1. ਵਰਜਨ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਇੱਕ ਨਵੀਂ ਉਦਾਹਰਣ ਤੈਨਾਤ ਕੀਤੀ ਗਈ ਹੈ 2.0.0.BADਜੋ ਕਿ ਡਾਟਾਬੇਸ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ v2bad
2. ਡਾਟਾਬੇਸ ਵਿੱਚ v2bad ਕਾਲਮ last_name ਹੁਣ ਮੌਜੂਦ ਨਹੀਂ ਹੈ - ਇਸ ਵਿੱਚ ਬਦਲਿਆ ਗਿਆ ਸੀ surname
3. ਡਾਟਾਬੇਸ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਅੱਪਡੇਟ ਸਫਲ ਰਿਹਾ ਅਤੇ ਕੁਝ ਉਦਾਹਰਨਾਂ ਚੱਲ ਰਹੀਆਂ ਹਨ 1.0.0, ਹੋਰ - ਵਿੱਚ 2.0.0.BAD. ਹਰ ਚੀਜ਼ ਡੇਟਾਬੇਸ ਨਾਲ ਜੁੜੀ ਹੋਈ ਹੈ v2bad
4. ਵਰਜਨ ਦੇ ਸਾਰੇ ਮੌਕੇ 1.0.0 ਗਲਤੀਆਂ ਸੁੱਟਣੀਆਂ ਸ਼ੁਰੂ ਕਰ ਦੇਣਗੇ ਕਿਉਂਕਿ ਉਹ ਕਾਲਮ ਵਿੱਚ ਡੇਟਾ ਪਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਗੇ last_nameਜੋ ਹੁਣ ਮੌਜੂਦ ਨਹੀਂ ਹੈ
5. ਵਰਜਨ ਦੇ ਸਾਰੇ ਮੌਕੇ 2.0.0.BAD ਬਿਨਾਂ ਕਿਸੇ ਸਮੱਸਿਆ ਦੇ ਕੰਮ ਕਰੇਗਾ

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਜੇਕਰ ਅਸੀਂ ਡੇਟਾਬੇਸ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਪਿੱਛੇ ਵੱਲ ਅਸੰਗਤ ਤਬਦੀਲੀਆਂ ਕਰਦੇ ਹਾਂ, ਤਾਂ A/B ਟੈਸਟਿੰਗ ਅਸੰਭਵ ਹੈ।

ਐਪਲੀਕੇਸ਼ਨ ਰੋਲਬੈਕ

ਮੰਨ ਲਓ ਕਿ A/B ਤੈਨਾਤੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਬਾਅਦ (ਲਗਭਗ ਪ੍ਰਤੀ.: ਲੇਖਕ ਦਾ ਮਤਲਬ ਸ਼ਾਇਦ ਏ/ਬੀ ਟੈਸਟਿੰਗ ਹੈ) ਅਸੀਂ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਕਿ ਸਾਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਵਰਜਨ 'ਤੇ ਵਾਪਸ ਲਿਆਉਣ ਦੀ ਲੋੜ ਹੈ 1.0.0. ਮੰਨ ਲਓ ਅਸੀਂ ਡੇਟਾਬੇਸ ਨੂੰ ਰੋਲਬੈਕ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦੇ।

ਕਦਮ:

1. ਅਸੀਂ ਵਰਜਨ ਐਪਲੀਕੇਸ਼ਨ ਉਦਾਹਰਨ ਨੂੰ ਰੋਕਦੇ ਹਾਂ 2.0.0.BAD
2. ਡਾਟਾਬੇਸ ਅਜੇ ਵੀ ਹੈ v2bad
3. ਸੰਸਕਰਣ ਤੋਂ ਲੈ ਕੇ 1.0.0 ਸਮਝ ਨਹੀਂ ਆਉਂਦਾ ਕਿ ਇਹ ਕੀ ਹੈ surname, ਅਸੀਂ ਗਲਤੀਆਂ ਦੇਖਾਂਗੇ
4. ਨਰਕ ਟੁੱਟ ਗਿਆ ਹੈ, ਅਸੀਂ ਹੁਣ ਵਾਪਸ ਨਹੀਂ ਜਾ ਸਕਦੇ

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਜੇਕਰ ਅਸੀਂ ਡੇਟਾਬੇਸ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਪਿੱਛੇ ਵੱਲ ਅਸੰਗਤ ਤਬਦੀਲੀਆਂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਪਿਛਲੇ ਸੰਸਕਰਣ 'ਤੇ ਵਾਪਸ ਨਹੀਂ ਜਾ ਸਕਦੇ।

ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲੌਗਸ

Backward incompatible scenario:

01) Run 1.0.0
02) Wait for the app (1.0.0) to boot
03) Generate a person by calling POST localhost:9991/person to version 1.0.0
04) Run 2.0.0.BAD
05) Wait for the app (2.0.0.BAD) to boot
06) Generate a person by calling POST localhost:9991/person to version 1.0.0 <-- this should fail
07) Generate a person by calling POST localhost:9992/person to version 2.0.0.BAD <-- this should pass

Starting app in version 1.0.0
Generate a person in version 1.0.0
Sending a post to 127.0.0.1:9991/person. This is the response:

{"firstName":"b73f639f-e176-4463-bf26-1135aace2f57","lastName":"b73f639f-e176-4463-bf26-1135aace2f57"}

Starting app in version 2.0.0.BAD
Generate a person in version 1.0.0
Sending a post to 127.0.0.1:9991/person. This is the response:

curl: (22) The requested URL returned error: 500 Internal Server Error

Generate a person in version 2.0.0.BAD
Sending a post to 127.0.0.1:9995/person. This is the response:

{"firstName":"e156be2e-06b6-4730-9c43-6e14cfcda125","surname":"e156be2e-06b6-4730-9c43-6e14cfcda125"}

ਡਾਟਾਬੇਸ ਤਬਦੀਲੀਆਂ

ਮਾਈਗ੍ਰੇਸ਼ਨ ਸਕ੍ਰਿਪਟ ਜੋ ਨਾਮ ਬਦਲਦੀ ਹੈ last_name в surname

ਸਰੋਤ ਫਲਾਈਵੇ ਸਕ੍ਰਿਪਟ:

CREATE TABLE PERSON (
id BIGINT GENERATED BY DEFAULT AS IDENTITY,
first_name varchar(255) not null,
last_name varchar(255) not null
);

insert into PERSON (first_name, last_name) values ('Dave', 'Syer');

ਸਕ੍ਰਿਪਟ ਜੋ ਨਾਮ ਬਦਲਦੀ ਹੈ last_name.

-- This change is backward incompatible - you can't do A/B testing
ALTER TABLE PERSON CHANGE last_name surname VARCHAR;

ਕੋਡ ਬਦਲਦਾ ਹੈ

ਅਸੀਂ ਖੇਤਰ ਦਾ ਨਾਮ ਬਦਲ ਦਿੱਤਾ ਹੈ lastName 'ਤੇ surname.

ਬੈਕਵਰਡ-ਅਨੁਕੂਲ ਤਰੀਕੇ ਨਾਲ ਇੱਕ ਕਾਲਮ ਦਾ ਨਾਮ ਬਦਲਣਾ

ਇਹ ਸਭ ਤੋਂ ਆਮ ਸਥਿਤੀ ਹੈ ਜਿਸਦਾ ਅਸੀਂ ਸਾਹਮਣਾ ਕਰ ਸਕਦੇ ਹਾਂ। ਸਾਨੂੰ ਪਿੱਛੇ ਵੱਲ ਅਸੰਗਤ ਤਬਦੀਲੀਆਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਸਾਬਤ ਕਰ ਚੁੱਕੇ ਹਾਂ ਕਿ ਜ਼ੀਰੋ-ਡਾਊਨਟਾਈਮ ਤੈਨਾਤੀ ਲਈ, ਸਾਨੂੰ ਵਾਧੂ ਕਦਮਾਂ ਤੋਂ ਬਿਨਾਂ ਡਾਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਲੇਖ ਦੇ ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਬੈਕਵਰਡ ਅਨੁਕੂਲਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਲੋੜੀਂਦੇ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਡੇਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੇ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ 3 ਤੈਨਾਤੀਆਂ ਕਰਾਂਗੇ।

ਨੋਟ. ਯਾਦ ਕਰੋ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਸੰਸਕਰਣ ਡੇਟਾਬੇਸ ਹੈ v1. ਇਸ ਵਿੱਚ ਕਾਲਮ ਹਨ first_name и last_name. ਸਾਨੂੰ ਬਦਲਣਾ ਪਵੇਗਾ last_name 'ਤੇ surname. ਸਾਡੇ ਕੋਲ ਐਪ ਦਾ ਸੰਸਕਰਣ ਵੀ ਹੈ 1.0.0, ਜੋ ਅਜੇ ਤੱਕ ਵਰਤਿਆ ਨਹੀਂ ਗਿਆ ਹੈ surname.

ਕਦਮ 2: ਉਪਨਾਮ ਸ਼ਾਮਲ ਕਰੋ

ਐਪ ਦਾ ਸੰਸਕਰਣ: 2.0.0
DB ਸੰਸਕਰਣ: v2

ਟਿੱਪਣੀ

ਇੱਕ ਨਵਾਂ ਕਾਲਮ ਜੋੜ ਕੇ ਅਤੇ ਇਸਦੀ ਸਮੱਗਰੀ ਦੀ ਨਕਲ ਕਰਕੇ, ਅਸੀਂ ਬੈਕਵਰਡ ਅਨੁਕੂਲ ਡੇਟਾਬੇਸ ਬਦਲਾਅ ਬਣਾਉਂਦੇ ਹਾਂ। ਉਸੇ ਸਮੇਂ, ਜੇਕਰ ਅਸੀਂ JAR ਨੂੰ ਰੋਲਬੈਕ ਕਰਦੇ ਹਾਂ ਜਾਂ ਇੱਕ ਪੁਰਾਣਾ JAR ਚੱਲ ਰਿਹਾ ਹੈ, ਤਾਂ ਇਹ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਨਹੀਂ ਟੁੱਟੇਗਾ।

ਅਸੀਂ ਇੱਕ ਨਵਾਂ ਸੰਸਕਰਣ ਪੇਸ਼ ਕਰ ਰਹੇ ਹਾਂ

ਕਦਮ:

1. ਇੱਕ ਨਵਾਂ ਕਾਲਮ ਬਣਾਉਣ ਲਈ ਇੱਕ ਡੇਟਾਬੇਸ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕਰੋ surname. ਹੁਣ ਤੁਹਾਡਾ DB ਸੰਸਕਰਣ v2
2. ਤੋਂ ਡਾਟਾ ਕਾਪੀ ਕਰੋ last_name в surname. ਧਿਆਨ ਦੇਵੋਕਿ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇਹ ਬਹੁਤ ਸਾਰਾ ਡਾਟਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਬੈਚ ਮਾਈਗ੍ਰੇਸ਼ਨ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ!
3. ਉਹ ਕੋਡ ਲਿਖੋ ਜਿੱਥੇ ਉਹ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਦੋਵੇਂ и новыйਅਤੇ ਪੁਰਾਣਾ ਕਾਲਮ ਹੁਣ ਤੁਹਾਡਾ ਐਪ ਸੰਸਕਰਣ 2.0.0
4. ਕਾਲਮ ਤੋਂ ਮੁੱਲ ਪੜ੍ਹੋ surname, ਜੇਕਰ ਇਹ ਨਹੀਂ ਹੈ null, ਜਾਂ l ਤੋਂast_name, ਜੇ surname ਨਹੀ ਦੱਸਇਆ. ਤੁਸੀਂ ਮਿਟਾ ਸਕਦੇ ਹੋ getLastName() ਕੋਡ ਤੋਂ, ਕਿਉਂਕਿ ਇਹ ਆਉਟਪੁੱਟ ਕਰੇਗਾ null ਤੋਂ ਤੁਹਾਡੀ ਅਰਜ਼ੀ ਨੂੰ ਵਾਪਸ ਕਰਨ ਵੇਲੇ 3.0.0 ਨੂੰ 2.0.0.

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

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

ਇਹ ਮਹੱਤਵਪੂਰਣ ਹੈ. ਤੁਹਾਨੂੰ ਵਿਧੀ ਨੂੰ ਹਟਾਉਣਾ ਚਾਹੀਦਾ ਹੈ getLastName(), ਕਿਉਂਕਿ ਸੰਸਕਰਣ ਵਿੱਚ 3.0.0 ਕੋਡ ਵਿੱਚ ਇੱਕ ਕਾਲਮ ਦੀ ਕੋਈ ਧਾਰਨਾ ਨਹੀਂ ਹੈ last_name. ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਉੱਥੇ null ਸੈੱਟ ਕੀਤਾ ਜਾਵੇਗਾ। ਤੁਸੀਂ ਵਿਧੀ ਨੂੰ ਛੱਡ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਲਈ ਚੈੱਕ ਜੋੜ ਸਕਦੇ ਹੋ null, ਪਰ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਹੱਲ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੋਵੇਗਾ ਕਿ ਤਰਕ ਵਿੱਚ getSurname() ਤੁਸੀਂ ਸਹੀ ਗੈਰ-ਜ਼ੀਰੋ ਮੁੱਲ ਚੁਣਿਆ ਹੈ।

A/B ਟੈਸਟਿੰਗ

ਮੌਜੂਦਾ ਸਥਿਤੀ ਇਹ ਹੈ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਹੈ 1.0.0, ਉਤਪਾਦਨ 'ਤੇ ਤੈਨਾਤ, ਅਤੇ ਡਾਟਾਬੇਸ ਵਿੱਚ v1. ਸਾਨੂੰ ਵਰਜਨ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਇੱਕ ਦੂਜੀ ਉਦਾਹਰਨ ਤੈਨਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ 2.0.0ਜੋ ਕਿ ਡੇਟਾਬੇਸ ਨੂੰ ਅਪਡੇਟ ਕਰੇਗਾ v2.

ਕਦਮ:

1. ਵਰਜਨ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਇੱਕ ਨਵੀਂ ਉਦਾਹਰਣ ਤੈਨਾਤ ਕੀਤੀ ਗਈ ਹੈ 2.0.0ਜੋ ਕਿ ਡਾਟਾਬੇਸ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ v2
2. ਇਸ ਦੌਰਾਨ ਕੁਝ ਬੇਨਤੀਆਂ 'ਤੇ ਵਰਜਨ ਉਦਾਹਰਨਾਂ ਦੁਆਰਾ ਕਾਰਵਾਈ ਕੀਤੀ ਗਈ ਸੀ 1.0.0
3. ਅੱਪਡੇਟ ਸਫਲ ਰਿਹਾ ਅਤੇ ਤੁਹਾਡੇ ਕੋਲ ਵਰਜਨ ਐਪਲੀਕੇਸ਼ਨ ਦੀਆਂ ਕਈ ਵਾਰ ਚੱਲ ਰਹੀਆਂ ਉਦਾਹਰਣਾਂ ਹਨ 1.0.0 ਅਤੇ ਹੋਰ ਸੰਸਕਰਣ 2.0.0. ਹਰ ਕੋਈ ਵਿੱਚ ਡੇਟਾਬੇਸ ਨਾਲ ਸੰਚਾਰ ਕਰਦਾ ਹੈ v2
4. ਵਰਜਨ 1.0.0 ਡੇਟਾਬੇਸ ਵਿੱਚ ਉਪਨਾਮ ਕਾਲਮ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦਾ, ਪਰ ਸੰਸਕਰਣ 2.0.0 ਵਰਤਦਾ ਹੈ। ਉਹ ਇੱਕ ਦੂਜੇ ਨਾਲ ਦਖਲ ਨਹੀਂ ਦਿੰਦੇ, ਅਤੇ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ.
5. ਵਰਜਨ 2.0.0 ਪੁਰਾਣੇ ਅਤੇ ਨਵੇਂ ਕਾਲਮ ਦੋਨਾਂ ਵਿੱਚ ਡਾਟਾ ਸਟੋਰ ਕਰਦਾ ਹੈ, ਪੱਛੜੀ ਅਨੁਕੂਲਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ

ਇਹ ਮਹੱਤਵਪੂਰਣ ਹੈ. ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਕੋਈ ਸਵਾਲ ਹਨ ਜੋ ਪੁਰਾਣੇ/ਨਵੇਂ ਕਾਲਮ ਦੇ ਮੁੱਲਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਆਈਟਮਾਂ ਦੀ ਗਿਣਤੀ ਕਰਦੇ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਯਾਦ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਹੁਣ ਡੁਪਲੀਕੇਟ ਮੁੱਲ ਹਨ (ਜ਼ਿਆਦਾਤਰ ਉਹ ਅਜੇ ਵੀ ਮਾਈਗ੍ਰੇਟ ਕਰ ਰਹੇ ਹਨ)। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਉਹਨਾਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਗਿਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਦਾ ਆਖਰੀ ਨਾਮ (ਜੋ ਵੀ ਕਾਲਮ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਅੱਖਰ ਨਾਲ ਸ਼ੁਰੂ ਹੋਇਆ ਸੀ A, ਫਿਰ ਜਦੋਂ ਤੱਕ ਡੇਟਾ ਮਾਈਗ੍ਰੇਸ਼ਨ ਪੂਰਾ ਨਹੀਂ ਹੋ ਜਾਂਦਾ (old → new ਕਾਲਮ) ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ ਕਾਲਮ ਪੁੱਛਦੇ ਹੋ ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਅਸੰਗਤ ਡੇਟਾ ਹੋ ਸਕਦਾ ਹੈ।

ਐਪਲੀਕੇਸ਼ਨ ਰੋਲਬੈਕ

ਹੁਣ ਸਾਡੇ ਕੋਲ ਐਪ ਦਾ ਸੰਸਕਰਣ ਹੈ 2.0.0 ਅਤੇ ਡਾਟਾਬੇਸ ਵਿੱਚ v2.

ਕਦਮ:

1. ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਵਰਜਨ 'ਤੇ ਵਾਪਸ ਭੇਜੋ 1.0.0.
2. ਵਰਜਨ 1.0.0 ਡੇਟਾਬੇਸ ਵਿੱਚ ਇੱਕ ਕਾਲਮ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦਾ ਹੈ surname, ਇਸ ਲਈ ਰੋਲਬੈਕ ਸਫਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ

DB ਬਦਲਦਾ ਹੈ

ਡੇਟਾਬੇਸ ਵਿੱਚ ਨਾਮ ਦਾ ਇੱਕ ਕਾਲਮ ਹੈ last_name.

ਫਲਾਈਵੇ ਸਰੋਤ ਸਕ੍ਰਿਪਟ:

CREATE TABLE PERSON (
id BIGINT GENERATED BY DEFAULT AS IDENTITY,
first_name varchar(255) not null,
last_name varchar(255) not null
);

insert into PERSON (first_name, last_name) values ('Dave', 'Syer');

ਸਕ੍ਰਿਪਟ ਸ਼ਾਮਲ ਕਰੋ surname.

ਧਿਆਨ. ਯਾਦ ਰੱਖੋ ਕਿ ਤੁਸੀਂ ਜੋ ਕਾਲਮ ਜੋੜ ਰਹੇ ਹੋ ਉਸ ਵਿੱਚ ਤੁਸੀਂ ਕੋਈ ਵੀ NOT NULL ਪਾਬੰਦੀਆਂ ਨਹੀਂ ਜੋੜ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਤੁਸੀਂ JAR ਨੂੰ ਰੋਲਬੈਕ ਕਰਦੇ ਹੋ, ਤਾਂ ਪੁਰਾਣੇ ਸੰਸਕਰਣ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਕਾਲਮ ਬਾਰੇ ਕੋਈ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੋਵੇਗੀ ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ ਆਪ NULL 'ਤੇ ਸੈੱਟ ਕਰ ਦੇਵੇਗਾ। ਜੇਕਰ ਅਜਿਹੀ ਕੋਈ ਸੀਮਾ ਹੈ, ਤਾਂ ਪੁਰਾਣੀ ਐਪਲੀਕੇਸ਼ਨ ਸਿਰਫ਼ ਟੁੱਟ ਜਾਵੇਗੀ।

-- NOTE: This field can't have the NOT NULL constraint cause if you rollback, the old version won't know about this field
-- and will always set it to NULL
ALTER TABLE PERSON ADD surname varchar(255);

-- WE'RE ASSUMING THAT IT'S A FAST MIGRATION - OTHERWISE WE WOULD HAVE TO MIGRATE IN BATCHES
UPDATE PERSON SET PERSON.surname = PERSON.last_name

ਕੋਡ ਬਦਲਦਾ ਹੈ

ਅਸੀਂ ਡੇਟਾ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸਟੋਰ ਕਰਦੇ ਹਾਂ last_name, ਅਤੇ ਅੰਦਰ surname. ਉਸੇ ਸਮੇਂ ਤੋਂ ਅਸੀਂ ਪੜ੍ਹਦੇ ਹਾਂ last_name, ਕਿਉਂਕਿ ਇਹ ਕਾਲਮ ਸਭ ਤੋਂ ਢੁਕਵਾਂ ਹੈ। ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਦੌਰਾਨ, ਕੁਝ ਬੇਨਤੀਆਂ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਉਦਾਹਰਨ ਦੁਆਰਾ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ ਜੋ ਅਜੇ ਤੱਕ ਅੱਪਡੇਟ ਨਹੀਂ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ।

/*
 * Copyright 2012-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package sample.flyway;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Person {
    @Id
    @GeneratedValue
    private Long id;
    private String firstName;
    private String lastName;
    private String surname;

    public String getFirstName() {
        return this.firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    /**
     * Reading from the new column if it's set. If not the from the old one.
     *
     * When migrating from version 1.0.0 -> 2.0.0 this can lead to a possibility that some data in
     * the surname column is not up to date (during the migration process lastName could have been updated).
     * In this case one can run yet another migration script after all applications have been deployed in the
     * new version to ensure that the surname field is updated.
     *
     * However it makes sense since when looking at the migration from 2.0.0 -> 3.0.0. In 3.0.0 we no longer
     * have a notion of lastName at all - so we don't update that column. If we rollback from 3.0.0 -> 2.0.0 if we
     * would be reading from lastName, then we would have very old data (since not a single datum was inserted
     * to lastName in version 3.0.0).
     */
    public String getSurname() {
        return this.surname != null ? this.surname : this.lastName;
    }

    /**
     * Storing both FIRST_NAME and SURNAME entries
     */
    public void setSurname(String surname) {
        this.lastName = surname;
        this.surname = surname;
    }

    @Override
    public String toString() {
        return "Person [firstName=" + this.firstName + ", lastName=" + this.lastName + ", surname=" + this.surname
                + "]";
    }
}

ਕਦਮ 3: ਕੋਡ ਤੋਂ ਆਖਰੀ_ਨਾਮ ਨੂੰ ਹਟਾਉਣਾ

ਐਪ ਦਾ ਸੰਸਕਰਣ: 3.0.0

DB ਸੰਸਕਰਣ:v3

ਟਿੱਪਣੀ

ਨੋਟ ਕਰੋ ਪ੍ਰਤੀ.: ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਮੂਲ ਲੇਖ ਵਿੱਚ ਲੇਖਕ ਨੇ ਗਲਤੀ ਨਾਲ ਇਸ ਬਲਾਕ ਦੇ ਪਾਠ ਨੂੰ ਕਦਮ 2 ਤੋਂ ਨਕਲ ਕੀਤਾ ਹੈ। ਇਸ ਪੜਾਅ 'ਤੇ, ਕਾਲਮ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਹਟਾਉਣ ਦੇ ਉਦੇਸ਼ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਵਿੱਚ ਬਦਲਾਅ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ। last_name.

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

ਐਪਲੀਕੇਸ਼ਨ ਰੋਲਬੈਕ

ਵਰਤਮਾਨ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਐਪ ਦਾ ਸੰਸਕਰਣ ਹੈ 3.0.0 ਅਤੇ ਡਾਟਾਬੇਸ v3. ਸੰਸਕਰਣ 3.0.0 ਵਿੱਚ ਡਾਟਾ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਕਰਦਾ ਹੈ last_name. ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਨ surname ਸਭ ਤੋਂ ਅੱਪ-ਟੂ-ਡੇਟ ਜਾਣਕਾਰੀ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਕਦਮ:

1. ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਵਰਜਨ 'ਤੇ ਵਾਪਸ ਭੇਜੋ 2.0.0.
2. ਵਰਜਨ 2.0.0 ਵਰਤਦਾ ਹੈ ਅਤੇ last_name и surname.
3. ਵਰਜਨ 2.0.0 ਲੈ ਜਾਵੇਗਾ surname, ਜੇਕਰ ਇਹ ਜ਼ੀਰੋ ਨਹੀਂ ਹੈ, ਨਹੀਂ ਤਾਂ -last_name

ਡਾਟਾਬੇਸ ਤਬਦੀਲੀਆਂ

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

-- WE'RE ASSUMING THAT IT'S A FAST MIGRATION - OTHERWISE WE WOULD HAVE TO MIGRATE IN BATCHES
-- ALSO WE'RE NOT CHECKING IF WE'RE NOT OVERRIDING EXISTING ENTRIES. WE WOULD HAVE TO COMPARE
-- ENTRY VERSIONS TO ENSURE THAT IF THERE IS ALREADY AN ENTRY WITH A HIGHER VERSION NUMBER
-- WE WILL NOT OVERRIDE IT.
UPDATE PERSON SET PERSON.surname = PERSON.last_name;

-- DROPPING THE NOT NULL CONSTRAINT; OTHERWISE YOU WILL TRY TO INSERT NULL VALUE OF THE LAST_NAME
-- WITH A NOT_NULL CONSTRAINT.
ALTER TABLE PERSON MODIFY COLUMN last_name varchar(255) NULL DEFAULT NULL;

ਕੋਡ ਬਦਲਦਾ ਹੈ

ਨੋਟ ਕਰੋ ਪ੍ਰਤੀ.: ਇਸ ਬਲਾਕ ਦਾ ਵਰਣਨ ਵੀ ਗਲਤੀ ਨਾਲ ਲੇਖਕ ਦੁਆਰਾ ਕਦਮ 2 ਤੋਂ ਕਾਪੀ ਕੀਤਾ ਗਿਆ ਸੀ। ਲੇਖ ਦੇ ਤਰਕ ਦੇ ਅਨੁਸਾਰ, ਇਸ ਪੜਾਅ 'ਤੇ ਕੋਡ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਦਾ ਉਦੇਸ਼ ਕਾਲਮ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਵਾਲੇ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣਾ ਹੈ। last_name.

ਅਸੀਂ ਡੇਟਾ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸਟੋਰ ਕਰਦੇ ਹਾਂ last_name, ਅਤੇ ਅੰਦਰ surname. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਕਾਲਮ ਤੋਂ ਪੜ੍ਹਦੇ ਹਾਂ last_name, ਕਿਉਂਕਿ ਇਹ ਸਭ ਤੋਂ ਢੁਕਵਾਂ ਹੈ। ਤੈਨਾਤੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਦੌਰਾਨ, ਕੁਝ ਬੇਨਤੀਆਂ ਇੱਕ ਉਦਾਹਰਣ ਦੁਆਰਾ ਸੰਸਾਧਿਤ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ ਜੋ ਅਜੇ ਤੱਕ ਅੱਪਗਰੇਡ ਨਹੀਂ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ।

/*
 * Copyright 2012-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package sample.flyway;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Person {
    @Id
    @GeneratedValue
    private Long id;
    private String firstName;
    private String surname;

    public String getFirstName() {
        return this.firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getSurname() {
        return this.surname;
    }

    public void setSurname(String lastname) {
        this.surname = lastname;
    }

    @Override
    public String toString() {
        return "Person [firstName=" + this.firstName + ", surname=" + this.surname
                + "]";
    }
}

ਕਦਮ 4: ਡੇਟਾਬੇਸ ਤੋਂ ਆਖਰੀ_ਨਾਮ ਨੂੰ ਹਟਾਉਣਾ

ਐਪ ਦਾ ਸੰਸਕਰਣ: 4.0.0

DB ਸੰਸਕਰਣ: v4

ਟਿੱਪਣੀ

ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਕਿ ਸੰਸਕਰਣ ਕੋਡ 3.0.0 ਕਾਲਮ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕੀਤੀ last_name, ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਕੁਝ ਵੀ ਬੁਰਾ ਨਹੀਂ ਹੋਵੇਗਾ ਜੇਕਰ ਅਸੀਂ ਵਾਪਸ ਮੁੜਦੇ ਹਾਂ 3.0.0 ਡੇਟਾਬੇਸ ਤੋਂ ਇੱਕ ਕਾਲਮ ਨੂੰ ਹਟਾਉਣ ਤੋਂ ਬਾਅਦ.

ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲੌਗਸ

We will do it in the following way:

01) Run 1.0.0
02) Wait for the app (1.0.0) to boot
03) Generate a person by calling POST localhost:9991/person to version 1.0.0
04) Run 2.0.0
05) Wait for the app (2.0.0) to boot
06) Generate a person by calling POST localhost:9991/person to version 1.0.0
07) Generate a person by calling POST localhost:9992/person to version 2.0.0
08) Kill app (1.0.0)
09) Run 3.0.0
10) Wait for the app (3.0.0) to boot
11) Generate a person by calling POST localhost:9992/person to version 2.0.0
12) Generate a person by calling POST localhost:9993/person to version 3.0.0
13) Kill app (3.0.0)
14) Run 4.0.0
15) Wait for the app (4.0.0) to boot
16) Generate a person by calling POST localhost:9993/person to version 3.0.0
17) Generate a person by calling POST localhost:9994/person to version 4.0.0

Starting app in version 1.0.0
Generate a person in version 1.0.0
Sending a post to 127.0.0.1:9991/person. This is the response:

{"firstName":"52b6e125-4a5c-429b-a47a-ef18bbc639d2","lastName":"52b6e125-4a5c-429b-a47a-ef18bbc639d2"}

Starting app in version 2.0.0

Generate a person in version 1.0.0
Sending a post to 127.0.0.1:9991/person. This is the response:

{"firstName":"e41ee756-4fa7-4737-b832-e28827a00deb","lastName":"e41ee756-4fa7-4737-b832-e28827a00deb"}

Generate a person in version 2.0.0
Sending a post to 127.0.0.1:9992/person. This is the response:

{"firstName":"0c1240f5-649a-4bc5-8aa9-cff855f3927f","lastName":"0c1240f5-649a-4bc5-8aa9-cff855f3927f","surname":"0c1240f5-649a-4bc5-8aa9-cff855f3927f"}

Killing app 1.0.0

Starting app in version 3.0.0

Generate a person in version 2.0.0
Sending a post to 127.0.0.1:9992/person. This is the response:
{"firstName":"74d84a9e-5f44-43b8-907c-148c6d26a71b","lastName":"74d84a9e-5f44-43b8-907c-148c6d26a71b","surname":"74d84a9e-5f44-43b8-907c-148c6d26a71b"}

Generate a person in version 3.0.0
Sending a post to 127.0.0.1:9993/person. This is the response:
{"firstName":"c6564dbe-9ab5-40ae-9077-8ae6668d5862","surname":"c6564dbe-9ab5-40ae-9077-8ae6668d5862"}

Killing app 2.0.0

Starting app in version 4.0.0

Generate a person in version 3.0.0
Sending a post to 127.0.0.1:9993/person. This is the response:

{"firstName":"cbe942fc-832e-45e9-a838-0fae25c10a51","surname":"cbe942fc-832e-45e9-a838-0fae25c10a51"}

Generate a person in version 4.0.0
Sending a post to 127.0.0.1:9994/person. This is the response:

{"firstName":"ff6857ce-9c41-413a-863e-358e2719bf88","surname":"ff6857ce-9c41-413a-863e-358e2719bf88"}

DB ਬਦਲਦਾ ਹੈ

ਬਾਰੇ v3 ਅਸੀਂ ਬਸ ਕਾਲਮ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ last_name ਅਤੇ ਗੁੰਮ ਪਾਬੰਦੀਆਂ ਸ਼ਾਮਲ ਕਰੋ।

-- REMOVE THE COLUMN
ALTER TABLE PERSON DROP last_name;

-- ADD CONSTRAINTS
UPDATE PERSON SET surname='' WHERE surname IS NULL;
ALTER TABLE PERSON ALTER COLUMN surname VARCHAR NOT NULL;

ਕੋਡ ਬਦਲਦਾ ਹੈ

ਕੋਡ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਹਨ।

ਸਿੱਟਾ

ਅਸੀਂ ਕਈ ਬੈਕਵਰਡ-ਅਨੁਕੂਲ ਤੈਨਾਤੀਆਂ ਕਰਕੇ ਸਫਲਤਾਪੂਰਵਕ ਇੱਕ ਪਿੱਛੇ-ਅਸੰਗਤ ਕਾਲਮ ਨਾਮ ਤਬਦੀਲੀ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਹੈ। ਹੇਠਾਂ ਕੀਤੀਆਂ ਗਈਆਂ ਕਾਰਵਾਈਆਂ ਦਾ ਸਾਰ ਹੈ:

1. ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਦੀ ਤੈਨਾਤੀ 1.0.0 с v1 ਡਾਟਾਬੇਸ ਸਕੀਮਾ (ਕਾਲਮ ਦਾ ਨਾਮ = last_name)
2. ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਦੀ ਤੈਨਾਤੀ 2.0.0, ਜੋ ਡਾਟਾ ਸਟੋਰ ਕਰਦਾ ਹੈ last_name и surname. ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਪੜ੍ਹਦਾ ਹੈ last_name. ਡੇਟਾਬੇਸ ਸੰਸਕਰਣ ਵਿੱਚ ਹੈ v2ਵਰਗੇ ਕਾਲਮ ਰੱਖਣ ਵਾਲੇ last_name, ਅਤੇ surname. surname l ਦੀ ਇੱਕ ਕਾਪੀ ਹੈast_name. (ਨੋਟ: ਇਸ ਕਾਲਮ ਵਿੱਚ ਕੋਈ null ਪਾਬੰਦੀ ਨਹੀਂ ਹੋਣੀ ਚਾਹੀਦੀ)
3. ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਦੀ ਤੈਨਾਤੀ 3.0.0, ਜੋ ਸਿਰਫ ਡਾਟਾ ਸਟੋਰ ਕਰਦਾ ਹੈ surname ਅਤੇ ਉਪਨਾਮ ਤੋਂ ਪੜ੍ਹਦਾ ਹੈ। ਡਾਟਾਬੇਸ ਲਈ, ਆਖਰੀ ਮਾਈਗਰੇਸ਼ਨ ਹੋ ਰਿਹਾ ਹੈ last_name в surname. ਇੱਕ ਸੀਮਾ ਵੀ ਨਹੀਂ ਤੋਂ ਹਟਾਇਆ ਗਿਆ last_name. ਡਾਟਾਬੇਸ ਹੁਣ ਸੰਸਕਰਣ ਵਿੱਚ ਹੈ v3
4. ਐਪਲੀਕੇਸ਼ਨ ਸੰਸਕਰਣ ਦੀ ਤੈਨਾਤੀ 4.0.0 - ਕੋਡ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਕੀਤੇ ਗਏ ਹਨ। ਡਾਟਾਬੇਸ ਤੈਨਾਤੀ v4, ਜੋ ਹਟਾਉਂਦਾ ਹੈ last_name. ਇੱਥੇ ਤੁਸੀਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਕੋਈ ਵੀ ਗੁੰਮ ਰੁਕਾਵਟਾਂ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹੋ।

ਇਸ ਪਹੁੰਚ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਤੁਸੀਂ ਡੇਟਾਬੇਸ/ਐਪਲੀਕੇਸ਼ਨ ਅਨੁਕੂਲਤਾ ਨੂੰ ਤੋੜੇ ਬਿਨਾਂ ਹਮੇਸ਼ਾਂ ਇੱਕ ਸੰਸਕਰਣ ਨੂੰ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹੋ।

ਕੋਡ

ਇਸ ਲੇਖ ਵਿੱਚ ਵਰਤਿਆ ਗਿਆ ਸਾਰਾ ਕੋਡ ਇੱਥੇ ਉਪਲਬਧ ਹੈ GitHub. ਹੇਠਾਂ ਵਾਧੂ ਵੇਰਵਾ ਹੈ।

ਪ੍ਰਾਜੈਕਟ

ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਕਲੋਨ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਫੋਲਡਰ ਬਣਤਰ ਨੂੰ ਦੇਖੋਗੇ।

├── boot-flyway-v1              - 1.0.0 version of the app with v1 of the schema
├── boot-flyway-v2              - 2.0.0 version of the app with v2 of the schema (backward-compatible - app can be rolled back)
├── boot-flyway-v2-bad          - 2.0.0.BAD version of the app with v2bad of the schema (backward-incompatible - app cannot be rolled back)
├── boot-flyway-v3              - 3.0.0 version of the app with v3 of the schema (app can be rolled back)
└── boot-flyway-v4              - 4.0.0 version of the app with v4 of the schema (app can be rolled back)

ਲਿਪੀਆਂ

ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਵਰਣਿਤ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ, ਜੋ ਡੇਟਾਬੇਸ ਵਿੱਚ ਪਿਛੜੇ-ਅਨੁਕੂਲ ਅਤੇ ਅਸੰਗਤ ਤਬਦੀਲੀਆਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਨਗੇ।

ਦੇਖਣ ਲਈ ਬੈਕਵਰਡ ਅਨੁਕੂਲ ਤਬਦੀਲੀਆਂ ਵਾਲਾ ਕੇਸ, ਰਨ:

./scripts/scenario_backward_compatible.sh

ਅਤੇ ਦੇਖਣ ਲਈ ਪਿੱਛੇ ਵੱਲ ਅਸੰਗਤ ਤਬਦੀਲੀਆਂ ਵਾਲਾ ਕੇਸ, ਰਨ:

./scripts/scenario_backward_incompatible.sh

ਸਪਰਿੰਗ ਬੂਟ ਸੈਂਪਲ ਫਲਾਈਵੇ

ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਤੋਂ ਲਈਆਂ ਗਈਆਂ ਹਨ Spring Boot Sample Flyway.

ਤੁਹਾਨੂੰ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਲੈ ਸਕਦੇ ਹੋ http://localhost:8080/flyway, ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ।

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ H2 ਕੰਸੋਲ ਵੀ ਸ਼ਾਮਲ ਹੈ (ਤੇ http://localhost:8080/h2-console) ਤਾਂ ਜੋ ਤੁਸੀਂ ਡੇਟਾਬੇਸ ਸਥਿਤੀ (ਡਿਫੌਲਟ jdbc URL ਹੈ jdbc:h2:mem:testdb).

ਵਾਧੂ

• ਡਾਟਾਬੇਸ ਰੀਫੈਕਟਰਿੰਗ ਪੈਟਰਨ
• ਲਗਾਤਾਰ ਡਿਲਿਵਰੀ

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

• ਕੁਬਰਨੇਟਸ: ਸਿਸਟਮ ਸਰੋਤ ਪ੍ਰਬੰਧਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ ਇੰਨਾ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ?
• ਟੇਕਟਨ ਪਾਈਪਲਾਈਨ - ਕੁਬਰਨੇਟਸ-ਦੇਸੀ ਪਾਈਪਲਾਈਨਾਂ
• Nginx ਲਈ ਡਾਇਨਾਮਿਕ ਮੋਡੀਊਲ ਬਣਾਉਣਾ
• ਹਾਸ਼ੀਕੋਰਪ ਕੌਂਸਲ ਦੇ ਕੁਬਰਨੇਟਸ ਅਧਿਕਾਰ ਦੀ ਜਾਣ-ਪਛਾਣ
• ਅਧਿਕਾਰ ਦੇ ਨਾਲ ਕਲਿਕਹਾਊਸ ਤੋਂ ਬਿਨਾਂ ਅਧਿਕਾਰ ਦੇ ਕਲਿੱਕਹਾਊਸ ਵਿੱਚ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕੀ ਹੋਇਆ?
• Nginx ਵੈੱਬ ਸਰਵਰ ਦੇ ਨਾਲ ਬਸੰਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਬਲੂ-ਗ੍ਰੀਨ ਡਿਪਲਾਇਮੈਂਟ

ਸਰੋਤ: www.habr.com