1. At the head of your code you could predeclare all your desired keys, either in an array or a series of scalars. In that way, you could directly harness strict to keep your keys in line.
2. A solution I think is a bit more elegant would be using constants to assign your allowed keys at start. Something like:

   #!/usr/bin/perl
   use strict;
   use warnings;
   
   use constant {KEY_1 => 0, KEY_2 => 1};
   my %hash = (KEY_1() => 5,
               KEY_2, 7);
   
   print $hash{KEY_1()};
   print @hash{KEY_1, KEY_2};
   [download]

   Note that constants are really subroutines (Thanks for the CB help tye), so trying to access them using $hash{KEY_1} will fail, though you could build in a little resilience by making the value of KEY_1 equal to 'KEY_1'.

Maybe I'm way off base, but it seems to me that a hash that only allows members of a known-at-compile-time list of keys is just an array with named indices, and would be better treated as such. This is much in line with kennethk's suggestion, except for the slight speed boost of using an array in the place of a hash. On the other hand, kennethk's solution allows a nice mix of compile-time checking and run-time flexibility:

use constant { COMPILE_KEY => 'compile_key' };
use strict;

my %hash = (
    COMPILE_KEY() => 'yay',
    runtime_key   => 'still OK'
);
$hash{COMPLIE_KEY()}; # sadness
[download]

Finally, if you don't care about speed, then Tie::StrictHash is designed to do exactly what you want, via (obviously) tieing.

UPDATE: Of course, now that I think about it, Tie::StrictHash obviously can't do any compile-time checking, so you're probably better with the non-tie-based Hash::Util that moritz recommended.