I will illustrate how one can perform operations using logical operations on the qubits, and using lattice surgery for two-qubit operations.
In the diagrams below, all of the 'dots' are data qubits: measurement qubits are omitted in order to help demonstrate the basic principles more clearly. The measurement qubits are there for when you perform stabiliser measurements, and are only ever involved in stabiliser measurements, so the story is about what you do with the data qubits — including such things as the stabiliser measurements that you perform on the data qubits.
Surface codes and logical single-qubit Pauli operations
One can use fragments of the plane to store qubits. The image below shows four qubits which are encoded as part of a larger lattice: the light dots with black outlines are qubits which are not involved in the encoded qubits, and can in principle be in any state that you like, unentangled from the rest.
In each of these fragments, the qubit is defined by the stabiliser relations which (ideally, in the absence of errors) hold among the qubits. For surface codes with the sorts of boundary conditions illustrated here, these are either 3-qubit X or Z stabilisers around the boundary, and either 4-qubit X or Z stabilisers in the 'bulk' or body of the code. The pattern of these stabilisers is illustrated below. Note that each X stabiliser that overlaps with a Z stabiliser, does so at two qubits, so that they commute with one another. (Apologies for the image size: I cannot manage to get it to display at a reasonable size.)
Note that by using the regularity of these stabilisers, it isn't necessary for the surface code fragment to be square (or even in principle rectangular).* This will become important later.
There are a number of (tensor product) Pauli operations which commute with all of these stabilisers. These may be used to define logical Pauli operators, which describe ways in which you can both access and transform the logical qubits. For instance, a product of Z operators across any row from boundary to boundary will commute with all stabilisers, and can be taken to represent a logical Z operator; a product of X operators across any column from boundary to boundary can similarly be take to represent a logical X operator:
It doesn't matter which row or which column you use: this follows from the fact that a product of any two rows of Z operators, or of any two columns of X operators, can be generated as a product of stabilisers and therefore realises an identity operation on the encoded qubit (as the stabiliser generators themselves are operators which perform the identity operation on an encoded qubit state, by definition). So: if you want to apply an X operation to an encoded qubit, one way to do so would be to apply such a logical X operation, by realising X operators on each qubit in a column reaching between two boundaries.**
Logical single-qubit Pauli measurements
One advantage of thinking of the encoded qubits in terms of logical operators is that it allows you to also determine how you can perform a 'logical measurement' — that is, a measurement not only of (some of) the qubits in the code, but of the data that they encode.
Take the logical X operator above, for example: the operator X⊗X⊗...⊗X is not only unitary, but Hermitian, which means that it is an observable which you can measure. (The same idea is used all the time with the stabilisers of the code, of course, which we measure in order to try to detect errors.)
This means that in order to realise a logical X measurement, it is enough to measure the logical X observable.
(The same goes for the logical Z observable, if you want to realise a standard basis measurement on your encoded qubit; and everything I say below can also be applied to logical Z measurements with the appropriate modifications.)
Now — measuring the logical X observable is not exactly the same as measuring each of those single-qubit X operators one at a time. The operator X⊗X⊗...⊗X has only two eigenvalues, +1 and −1, so measuring that precise operator can only have two outcomes, whereas measuring each of n qubits will have 2n outcomes.
Also, measuring each of those single-qubit X operators will not keep you in the code-space: if you want to do computations on a projected post-measurement state, you would have to do a lot of clean-up work to restore the qubit to a properly encoded state.
However: if you don't mind doing that clean-up work, or if you don't care about working with the post-measurement state, you can simulate the logical X measurement by doing those single-qubit measurements, obtaining +1 and −1 outcomes, and then computing their products to obtain what the result of the measurement of X⊗X⊗...⊗X "would have" been.
(More precisely: measuring all of those single-qubit X operators is something that does not disturb a state which would result from a measurement of the tensor product operator X⊗X⊗...⊗X, and the product of those single-qubit measurements would have to yield a consistent outcome with the tensor product operator X⊗X⊗...⊗X, so we can use this as a way to simulate that more complicated measurement if we don't mind all of the qubits being projected onto conjugate basis states as a side-effect.)
Lattice surgery for logical two-qubit operations
To realise a two-qubit operation, you can use a technique known as lattice surgery, wherein you 'merge' and 'split' different patches of the 2D lattice to realise operations between those patches (see [arXiv:1111.4022], [arXiv:1612.07330], or [arXiv:1704.08670] for complete descriptions of these operations. Disclosure: I am an author on the third of these articles.)
This may be realised between two adjacent patches of the planar lattice (as illustrated above) by preparing those "uninvolved" rows and columns of qubits in a suitable state, and then measuring stabilisers which previously you were not measuring in order to extend the memory to a larger system.
(In the diagram below, the horizontal spacing between the code segments and the column of qubits in the |0〉 states is exaggerated for effect.)
This will affect the logical operators of the system in a non-unitary way, and is most often used (see [arXiv:1612.07330] for example) to realise a coherent X⊗X or Z⊗Z measurement, which can be composed to realise a CNOT operation [arXiv:1612.07330, Fig. 1(b)]:
In this way, you can realise a CNOT operation between a pair of encoded qubits.***
* You can also use slight modifications of the regular pattern of stabilisers, as Letinsky [arXiv:1808.02892] demonstrates, to achieve more versatile planar-surface representations of encoded qubits.
** In practise, rather than explicitly performing (imperfect single-qubit) operations, you would take advantage of the fact that the frame of reference for the encoded qubits is one which you are fixing by convention, and update (or 'transform') the reference frame rather than the state itself when you wish to realise a Pauli operation. This is the smart way to go about error correction as well: to treat errors not as 'mistakes' which must be 'fixed', but as an uncontrolled but observable drift in your reference frame as a result of interaction with the environment. You then hope that this drift is slow enough that you can track it accurately, and compensate for the change in reference frame when you do your computation. Particularly in the context of tracking errors, this reference frame is described as the Pauli frame, and its job is to describe the frame of reference in terms of the Pauli operations which would be required to put the system in the state usually described by an error-free error correcting code.
*** Many authors would describe this construction as the point of lattice surgery, and it is certainly the original concrete application of it described in the original article [arXiv:1111.4022]. It is possible in principle to do more elaborate operations using splits and merges, by treating the merges and splits as primitive operations in their own right rather than just the components of a CNOT, and using more versatile (but not especially circuit-like) transformations — this is essentially the point of my article with Dom Horsman [arXiv:1704.08670], which opens up the possibility of the ZX calculus (a somewhat heterodox representation of quantum computation) to be directly practically useful for surface-code memories.