You don't; you pass that information as arguments:

app () {
    server_name=$1
    zone=$2
    # ...
}


app "$SERVER_NAME" "$ZONE"

Disclaimer: Declaring functions dynamically is not the approach you should use. See chepner's answer, that is definitely the preferred way!

However, if you really want to create the name dynamically, here is another way to do it, that is a little less problematic than eval:

#!/usr/bin/env bash 

SERVER_NAME=foo
ZONE=bar

shopt -s expand_aliases
alias name="APP_${SERVER_NAME}_$ZONE"

name() { 
   echo hello
}

declare -fp "APP_${SERVER_NAME}_${ZONE}"

The output of declare shows that APP_foo_bar has been declared:

APP_foo_bar () 
{ 
    echo hello
}

Now, this works to some degree. You have to be very cautious if the input is not under your control. This can be potentially dangerous:

#!/usr/bin/env bash 

SERVER_NAME='foo() { echo hi; }; echo ouch;'
ZONE=bar

shopt -s expand_aliases
alias name="APP_${SERVER_NAME}_$ZONE"

name() { 
   echo hello
}

declare -fp APP_foo
declare -fp _bar

When the right alias is used, this approach can be used to execute arbitrary code. The output of this script is:

ouch
APP_foo () 
{ 
    echo hi
}
_bar () 
{ 
    echo hello
}

Not only were the wrong functions declared, echo ouch got executed! Now imagine if I used rm -rf *. Using eval presents the exact same problem.

Conclusion: Don't do it :)

You should not do this, unless you have a good reason for it - functions are reusable encapsulations of code, and their names should not change normally. Also you should not use eval because it is very dangerous. So be warned.

What you can do if you absolutely must is use eval:

#!/bin/bash

eval "function APP_${SERVER_NAME}_${ZONE}
{
    echo 'XXX'
}"

APP_${SERVER_NAME}_${ZONE}

The result:

XXX

As others have said, it is not a good idea to generate function (or variable) names dynamically, instead you can use an associative array in a structure sometimes called a despatch table.

The idea is that the keys of the associative array (sometimes called a 'hash', 'hash table', or dictionary) hold the names of functions. When you need a particular function you just call it. Here is a simple example:

# Statically declare each function

func1() {
    echo "This is func1"
}

func2() {
    echo "This is func2"
}

# Declare the array as associative
declare -A lookup

# Setup the association of dynamic name with function
lookup[APP_fred_CBD]='func1'
lookup[APP_jim_ABCD]='func2'

SERVER_NAME='fred'
ZONE='CBD'
${lookup[APP_${SERVER_NAME}_${ZONE}]}

SERVER_NAME='jim'
ZONE='ABCD'
${lookup[APP_${SERVER_NAME}_${ZONE}]}

Gives:

This is func1
This is func2

If you application does not require unique functions, you can use the same function for more than one key, and pass parameters.