Migration and deployment from Unix to Linux: porting, upgrading, and testing

To migrate from Unix to Linux, a sandbox environment should be established in the initial stage for testing. Your entire team may not have any Linux experience, and such a sandbox environment can be of great help (without worrying about any risks ).

Issues related to code and compilation. Are you using JAVA or C? Is there any third-party application to be migrated? Can these third-party software be transplanted to Linux?

Assume that you are using the C language. Suppose you will compile the code on Linux. If you use the GNU (gcc) compiler, because this is an industrial standard, and this is a Linux compiler. All applications compiled on other platforms need to be re-compiled.

There are two methods for compiling. One way is to recompile your program in the existing environment. In this case, you must ensure that all the tools you need in this environment, including source code and file generation. If you want to use this method, do it in your testing environment and never implement it in the production environment.

Another way is to port all the data and code to the new environment and test them. Test the hardware platform. If you plan to update the hardware platform, some hardware-related code may cause you some trouble. The worst case is that you may have to rewrite all the code.

Make sure that developers are involved. Do not assume anything. Important considerations include runtime APIs, system calls, stream and database support. Make sure that you fully understand the content to be transplanted. In this case, you need to evaluate and verify all things, such as applications and their library files and dependencies. You can quickly determine whether or not the product runs on Linux and where it runs.

There is no doubt that Java programs can be transplanted faster than C Programs. In addition, during the migration process, you also need to verify the test environment, user interface requirements, platform reliability restrictions, middleware Products and internal skills. Every environment that is not careful may cause you troubles in the future.

Application upgrade

Applications are the most important part in the porting process. In some cases, your application can be transplanted directly, but this rarely happens. In another case, you must recompile them on the new platform. The porting and compilation processes are not complex. What you need to do is to test to confirm that everything is OK.

The porting process of an application should include development and testing. When porting, you must have a reliable way to ensure that your database is transplanted correctly. In addition, kernel extensions and preparation drivers required by applications are not necessarily met on the new platform, because most kernel APIs do not strictly follow the standards.

Are applications using third-party components, such as database tools, application servers, or other middleware? If yes, this will increase the complexity of porting. Is the application 32-bit or 64-bit? If it is transplanted from 32-bit to 64, you will have to spend more time. How can applications communicate with databases? Do they use database interfaces, such as ODBC or programming languages, such as C ++? You must consider these aspects carefully. From a human perspective, try to include people with various transplant project experiences into your team.

Stability and Performance Evaluation

Usually in the first few weeks, various application problems will emerge one after another, and engineers will try to solve them as soon as possible. At this time, you may want to review your project plan and adjust the delivery time.

It is critical to test the stability, functionality, and performance of applications. Instead of spending $2 million on developing a new system, it would be cheaper to spend $2000 on testing. The test sequence is usually as follows:

The migration engineer performs module tests on the applications to be transplanted.

The application engineer performs a functional test.

User Acceptance Test (UAT ). The actual commercial users in this phase are tested.

Performance engineers perform performance tests.

Stress Testing of the application to be migrated is indispensable during the testing process, ensuring that the new system can cope with various loads. At this point, you should have completed the basic test, and you should be aware of the performance of the application in the old environment and the new environment.

Similar tests are required for stability and performance. Try to beat your system. Use tools such as HP LoadRunner to simulate a normal load of 5 times.

Now it is time to discover bugs. Of course this is not in the production environment. Before entering the production environment, you have the opportunity to debug the problem. Use the test to Prevent Users who use the system from verifying whether the problem exists. Business content must also be involved, and there should be an independent UAT plan. If your system has high availability in the old environment, you must test whether the high availability continues to work in the new environment.