Error-correction in quantum computing is designed to get around the decoherence "washing out" the answer to a computation. But wouldn't the introduction of error-correction procedures or apparatus merely increase the production of entropy and produce more decohrence?
Of course this is true, the point of a useful error correcting scheme is that the errors introduced with the additional complexity needed to implement the scheme are either themselves corrected or less likely than the one it's supposed to correct.
Let's take the example of a simple classical repetition code: say you want to encode a single classical bit, which can be either $0$ or $1$, to protect it from a binary symmetric noise, i.e. an error that simply flips the bit with probability $p$ (from $0$ it goes to $1$ with probability $p$ and vice versa). A possible strategy is to use two additional bits the following encoding:
$$0\rightarrow 000 \\1\rightarrow111$$
now if one of the bits flip, we can just take the majority vote to figure out what was the original bit value. For instance we interpret $010$ as $000$, with an error on the middle bit.
But as you point out, adding two bits adds complexity, and multiple bits can now be flipped: before the encoding, just one bit flip was possible, now there are three bits that could flip, effectively "triplicating" the possible errors that can occur! Haven't we just made things worse? Well no, because even if $010$ could have been produced by $111$ with an error on the first and last bit, the flipping of two bits happens with probability $p^2$, so it's much less probable than the flipping of a single bit, which happens with probability $p$. So, despite apparently making things worse, the repetition code actually decreases the error rate.
The repetition code is not practical in many ways, but for any (quantum) error-correcting code the point is that it must correct errors faster than it creates them. The quantum threshold theorem roughly states that if the error rate of a quantum computer is small enough, then errors can be effectively corrected by an error-correcting scheme.
You are absolutely right that by adding extra qubits, and extra error correction operations, you also produce extra entropy.
However, with more qubits it is also possible to move all the entropy onto a subset of the qubits, making some those qubits more noisy, while the remaining -- those which become error corrected -- become less noisy! By discarding the qubits on which the entropy has been bundled and replacing them by fresh ones (or measuring + re-initalizing), entropy is removed from the system. This way, one effective reduces the entropy production on the error corrected qubits.