How to join each of the spheres? Or, how to make a 3D grid?

One way to do it:

lines = With[{j = 0, k = 1, h = 0.2},
  {Table[Line[{{x, y, j}, {x, y, k}}], {x, j, k, h}, {y, j, k, h}], 
  Table[Line[{{x, j, z}, {x, k, z}}], {x, j, k, h}, {z, j, k, h}], 
  Table[Line[{{j, y, z}, {k, y, z}}], {y, j, k, h}, {z, j, k, h}]}];

Graphics3D[
  {{RGBColor[#], Sphere[#, 1/50]} & /@ Tuples[Range[0, 1, 1/5], 3],
  lines}, Boxed -> False]

... and another way using rotations:

 tpls = Tuples[Range[0, 1, 1/5], 3];
 lines3 = Table[Partition[RotateRight[#, k] & /@ tpls, 6], {k, 0, 2}];
 Graphics3D[{{RGBColor[#], Sphere[#, 1/40]} & /@ tpls, Tube /@ lines3}, Boxed -> False]

{a, b, h} = {0, 1, 0.2};
lines = Tube /@ Flatten[Table[{{i, j, k}, {j, k, i}, {k, i, j}}, 
    {i, a, b, h}, {j, a, b, h}, {k, {a, b}}], {1, 2, 4}];

spheres = {RGBColor[#], Sphere[#, 1/50]} & /@ Tuples[Range[a, b, h], 3];

Graphics3D[{lines, spheres}, Boxed -> False]

also

lines = Table[Tube /@ Transpose@Table[{{i, j, k}, {j, k, i}, {k, i, j}}, {k, {a, b}}], 
    {i, a, b, h}, {j, a, b, h}];

The previous answer

k = 0.2;
Graphics3D[
 {{RGBColor[#], Sphere[#, 1/50]} & /@ Tuples[Range[0, 1, k], 3],
  Table[{
    Line@{{{i, j, 0}, {i, j, 1}}, {{i, 0, j}, {i, 1, j}}, {{0, i, j}, {1, i, j}}}}, 
     {i, 0, 1, k}, {j, 0, 1, k}]}, Boxed -> False
]
    

With[{data = Tuples[Range[0, 1, 1/5], 3]}, 
 Graphics3D[{
   Table[Line /@ i /@ data, 
     {i, {{#, {#[[1]], #[[2]], 1}} &, {#, {#[[1]], 1, #[[3]]}} &, {#, {1, #[[2]], #[[3]]}} &}}
   ],
  {RGBColor[#], Sphere[#, 1/50]} & /@ data}, Boxed -> False
  ]
]

Continuing on VLC's code

It doesn't really matter in this case, but when having lots of lines you get a speed increase by creating just one Line object.

This creates one line from each ball on the edge to the ball on the opposite edge, and then issuing Line[{line1,line2,line3,...}]

ballGridColorized[n_] := Module[{lines},
  lines = Line[Flatten[Table[{
       {{i, j, 0}, {i, j, 1}},
       {{i, 0, j}, {i, 1, j}},
       {{0, i, j}, {1, i, j}}},
      {i, 0, 1, 1/n}, {j, 0, 1, 1/n}], 2]];
  Graphics3D[{{RGBColor[#], Sphere[#, 1/(10 n)]} & /@ 
     Tuples[Range[0, 1, 1/n], 3], lines}, Boxed -> False]]

If it wasn't for the coloring the same could be done for the Spheres with Sphere[{p1,p2,p3,...},r]

ballGrid[n_] := Module[{lines},
  lines = Line[Flatten[Table[{
       {{i, j, 0}, {i, j, 1}},
       {{i, 0, j}, {i, 1, j}},
       {{0, i, j}, {1, i, j}}},
      {i, 0, 1, 1/n}, {j, 0, 1, 1/n}], 2]];
  Graphics3D[{Sphere[Tuples[Range[0, 1, 1/n], 3], 1/(10 n)], lines}, 
   Boxed -> False]]

On my computer ballGridColorized[20] slows down my notebook and I can't rotate it or anything while ballGrid[20] flows nicely and is about a factor 10 faster to display in the first place. I don't know if that's because of the lack of color or because the Spheres are created like that

Perhaps there is a way to provide style options even when creating Spheres this way that I don't know about :)

Cut down the number of line segments by an order of magnitude ($108$ versus $540$) by running them from one face to the opposite face rather than from each ball to the next. Here, I recycle the coordinates x via the function f by extracting the coordinates on one of the six faces (with Cases), creating a segment to the opposite face (two applications of Insert), and permuting the segment's coordinates to construct two more segments for the two other pairs of faces (by varying the third arguments of the Insert functions over Range[3]). Putting them all into a single Line object (by first flattening the list) may help make the manipulation more responsive, too.

x = Tuples[Range[0, 1, 1/5], 3];
f[u_, v_] := {Insert[{u, v}, 0, #], Insert[{u, v}, 1, #]} & /@ Range[3];
Graphics3D[{Thickness[0.003], Gray, Line @ Flatten[Cases[x, {0, u_, v_} :> f[u, v]], 1], 
  {RGBColor[#], Sphere[#, 1/50]} & /@ x}, Boxed -> False]

As simple as doable? How about

GridGraph[{6, 6, 6}]

Rather than manually drawing Lines, you can use Cuboid:

Graphics3D[{{{RGBColor[#], Sphere[#, 1/50]} & /@ Tuples[Range[0, 1, 1/5], 3]}, 
  FaceForm[None], Cuboid[#, # + 1/5] & /@ Tuples[Range[0, 4/5, 1/5], 3]}, Boxed -> False]

Here's how to do it using GridGraph:

n = 5;

g = GridGraph[{n, n, n}];

Graphics3D@
 GraphicsComplex[
  Tuples[Range[n], 3], 
  {Composition[Line, List] @@@ EdgeList[g], 
   Sphere[#, .1] & /@ Range[n^3]}]

This solution relies on a (somewhat accidental but very likely) matching order between the outputs of Tuples and GridGraph.