The best explanation can be found (as always) on Martin Fowler's bliki article on Immutable Servers.
A server, be it hardware or a virtual server in the cloud, usually has an operating system and application running on it.
Often application, and components of the operating system, require configuration and require changes to be applied. For example security patches, deployment of new versions of the application and configuration changes.
When you consider that any change is a mutation on the state of the server, the term
immutable starts to make more sense. It means that no mutations are allowed on such a server.
It is often the case, when people are involved in changing the state of the server - be it a deployment of a version, or configuration change, or a security path. The result is a server that is no longer working as expected. For example, the application might not run now because of misconfiguration, etc.
This is why a practice for creating immutable servers is established. With immutable servers, an image of a server is created with all the configuration, patches, application versions bundled in. Then that server image can be used to create servers in various environments.
The first environment where such an image is used, would be an environment where the image can be tested to work. Any abnormalities are detected, and only then such an image can be promoted to a production environment to replace the servers there with the new version (which is known to work well).
Once the process of creating the images and promoting the images is automated, you get a very failure-proof process that involves very little human effort and very low chance to introduce failure into your service.
Often immutable servers don't even include any way to "enter" them, such as for example the ssh server is missing. In this case it is also often the case that all the metrology of a server (metrics, logs) is shipped to systems outside such as a metrics database or log aggregation service.
With containers (see: Docker) there is also a process to create images, and then spawn these into running containers. These are quite often replaced by new containers based on updated images, and are never mutated. Meaning that no human enters into the container to "fix something" by introducing a change.