How to match a string containing the character "$" with grep?

In this case, the string in $param will be interpreted as a regular expression. This expression contains a $ which anchors the ambari_parameter in the pattern to the end of the match. Since ambari_parameter$ in the input data does not contain ambari_parameter at the very end (due to the $ at the end of the string), it won't match.

You could just escape the $ as \$ in the pattern (\\$ in a double quoted string), or place the $ in a bracketed group as [$], but since you seem to want to do a string match rather than a regular expression match, it may be more appropriate to use -F:

echo 'ambari_parameter$' | grep -F -e "$param"

Using grep -F makes grep treat the given pattern as a string rather than as a regular expression. Each character in the pattern will therefore be match literally, even the $ at the end.

I also used -e here to force grep to recognize the following argument as a pattern. This is necessary if $param starts with a dash (-). It's generally good to use -e whenever the pattern you match with is given in a variable.

To further require that the whole input line matches the complete string, add -x:

echo 'ambari_parameter$' | grep -xF -e "$param"

If $param is ambari_parameter$, then this will not match the string _ambari_parameter$ or ambari_parameter$100 (but will match if -x is left out).

If you have a whole pattern you want to match literally then don't treat it as a regular expression. If you do need to match a literal $ in a regular expression, use \$.

Like ., \, and several other punctuation characters, $ is a metacharacter in regular expressions. The $ character matches the empty string at the end of a line (so x$ matches x but only at the end of a line). If your pattern doesn't contain any metacharacters, then you don't need to treat it as a regular expression and you should use grep -F as Kusalananda explains.

If you really do need to match a $ or any other metacharacter literally in a regular expression, escape it with the \ metacharacter. To match a literal $ write \$, to match a literal \ write \\, and so forth.

param='ambari_parameter\$'
echo "ambari_parameter$" | grep "$param"

When you assign to param in the shell, enclose the regular expression in single quotes (' ') as shown above, because $ and \ also have special meanings in most shells, including all Bourne-style shells (you tagged bash). \ in shells works basically the same as in regular expressions. ($ doesn't; it's used for various shell expansions/substitutions, especially parameter expansion).

Unquoted, or even in double quotes, \$ indicates a literal $ in the shell, which is then passed to grep as $ which grep interprets as a regular expression metacharacter. Enclosing it in single quotes prevents this. You could alternatively write \\\$--or sometimes just \\$--but that's confusing.

You should escape the special characters in case you are looking for exact match of them as this ways:

if it's in single quote, one escape is required.

grep 'parameter\$'

if it's in double quote or not quoted, one escape more is required.

grep "parameter\\$" #or
grep parameter\\$

Note that any space within match if not quoted, should be escaped as well.

grep para\ meter\\$