You can use printf:

JSON_FMT='{"bucketname":"%s","objectname":"%s","targetlocation":"%s"}\n'
printf "$JSON_FMT" "$BUCKET_NAME" "$OBJECT_NAME" "$TARGET_LOCATION"

much clear and simpler

To output text, use echo rather than cat (which outputs data from files or streams).

Aside from that, you will also have to escape the double-quotes inside your text if you want them to appear in the result.

echo -e "Name of your app?\n"
read appname
echo "{apps:[{name:\"${appname}\",script:\"./cms/bin/www\",watch:false}]}" > process.json

If you need to process more than just a simple line, I second @chepner's suggestion to use a JSON tool such as jq.

Your -bash: process.json: Permission denied comes from the fact you cannot write to the process.json file. If the file does not exist, check that your user has write permissions on the directory. If it exists, check that your user has write permissions on the file.

The following programs can output json:

lshw:

lshw -json

smartmontools v7+:

smartctl --json --all /dev/sda

lsblk:

lsblk --json

lsipc:

lsipc --json

sfdisk

sfdisk --json

Answer

This should get you the exact syntax you require:

In the example , the file containing your CIDR values is named cidr.txt and appears to contain only IP addresses along with subnets, i.e. other parameters remain constant. If you actually need to change these additional parameters (i.e. the port ranges you provided are not actually the same for all cidr then I will update my answer, and provide a fully fleshed out template)

Additionally, you will require 'jq' , which is the ubiquitous application for dealing with JSON through bash. It may likely already be installed these days, but if not then sudo apt install jq per usual.

while read cidr ; do 
   jq -n --arg CIDR "$cidr" '{"source":$CIDR,"protocol":"17","isStateless":true,"udpOptions": {"destinationPortRange":{"max": 65535,"min": 1},"sourcePortRange": {"min":521,"max": 65535}  }}'  
done < cidr.txt | jq --slurp

Using the four-line file sample you provided, the output of the above will give you the following in the terminal:

[
  {
    "source": "1.1.1.0/22",
    "protocol": "17",
    "isStateless": true,
    "udpOptions": {
      "destinationPortRange": {
        "max": 65535,
        "min": 1
      },
      "sourcePortRange": {
        "min": 521,
        "max": 65535
      }
    }
  },
  {
    "source": "2.2.2.0/24",
    "protocol": "17",
    "isStateless": true,
    "udpOptions": {
      "destinationPortRange": {
        "max": 65535,
        "min": 1
      },
      "sourcePortRange": {
        "min": 521,
        "max": 65535
      }
    }
  },
  {
    "source": "5.5.5.0/21",
    "protocol": "17",
    "isStateless": true,
    "udpOptions": {
      "destinationPortRange": {
        "max": 65535,
        "min": 1
      },
      "sourcePortRange": {
        "min": 521,
        "max": 65535
      }
    }
  },
  {
    "source": "6.6.0.0/16",
    "protocol": "17",
    "isStateless": true,
    "udpOptions": {
      "destinationPortRange": {
        "max": 65535,
        "min": 1
      },
      "sourcePortRange": {
        "min": 521,
        "max": 65535
      }
    }
  }
]

UPDATE

In order to fix the above output, you need to "repair" the line termination of your CIDR file. There are two ways of doing so:

Answer 1:

You can make the following changes to your script

#!/bin/bash

# There are four changes made to the script:
# 1. The addition of `tr` in order to eliminate '\r'.
# 2. Removal of '[' and ']' inside the `jq` command.
# 3. Addition of `jq --slurp` to enforce your specified JSON format. 
# 4. Addition of double-quotes around `$lel` to prevent splitting.

 
lel=$(while read cidr ; do 
       cidr=$(echo "$cidr" | tr -d '\r' );     
       jq -n --arg CIDR "$cidr" '{"source":$CIDR,"protocol":"17","isStateless":true,"udpOptions": {"destinationPortRange":{"max": 65535,"min": 1},"sourcePortRange": {"min":521,
"max": 65535}  }}' 
  done < lol | jq --slurp )
echo "$lel"

Alternative answer

You can "repair" the file containing our list of CIDRs:

cp lol lol_old
cat lol_old | tr -d '\r' > lol

Then, you can use the earlier version of your script, albeit with the corrections explained in #2-4 comments of the script included above.

Explanation

The reason for the \r found in your output is actually found in the formatting of your particular file containing your CIDRs, which happens to follow Windows - and not Unix - line termination standard.

The \r symbol you see in your output is actually present in your source file as well, where it is used along with \n to terminate each individual line. Both \r and \n are invisible characters. The combination of \r\n is known as CRLF - carriage return + line feed - which is a remnant from the age of typewriters, yet for some reason is still used by Windows systems. On the other hand, Unix uses only LF to terminate lines, where it is represented by \n in its escaped form.

To confirm this peciular behavior, you can try executing the following:

head -n 1 lol | xxd -ps 
312e312e312e302f32320d0a

In the above output - the first line of your file converted to its hex form - ends with 0d0a. This HEX combination represent CR+LF. On the other hand, if you execute the following directly inside of your Bash terminal:

echo "abcd"  | xxd -ps
616263640a

you will find that the output follows Unix standard, where the line termination uses simple 0a, i.e. the hex representation of LF.

Note: This line-termination issue is incredibly common, widespread and something one always needs to be on the lookout for operating from inside Unix on files that may have been generated under Windows.

Info regarding jq

The above example (the while read loop) sends its output to the terminal, but you can of course use redirection if you need to store it in a file, using the standard syntax:

while read cidr; do [...] ; done < cidr.txt > outcidr.json

This file will contain the pretty-printed JSON output, but if you need/prefer your output to be contstrained to a single line, you can do:

cat outcidr.json | tr -d '\n' | tr -s ' '

More importantly, if you ever in the future end up with a single-line, complex JSON output that looks impossible to decipher, jq can be used to reformat and pretty-print it`:

echo '[{"source":"1.1.1.0/24","protocol":"17","isStateless":true,"udpOptions":{"destinationPortRange":{"max":55555,"min":10001},"sourcePortRange":{"min":521,"max":65535}}},{"source":"2.2.2.0/24","protocol":"17","isStateless":true,"udpOptions":{"destinationPortRange":{"max":55555,"min":10001},"sourcePortRange":{"min":521,"max":65535}}},{"source":"3.3.3.0/24","protocol":"17","isStateless":true,"udpOptions":{"destinationPortRange":{"max":55555,"min":10001},"sourcePortRange":{"min":521,"max":65535}}}]' > bad_output.json

cat bad_output.json | tr -d '\r' | jq '' 

[
  {
    "source": "1.1.1.0/24",
    "protocol": "17",
    "isStateless": true,
    "udpOptions": {
      "destinationPortRange": {
        "max": 55555,
        "min": 10001
      },
      "sourcePortRange": {
        "min": 521,
        "max": 65535
      }
    }
  },
  {
    "source": "2.2.2.0/24",
    "protocol": "17",
    "isStateless": true,
    "udpOptions": {
      "destinationPortRange": {
        "max": 55555,
        "min": 10001
      },
      "sourcePortRange": {
        "min": 521,
        "max": 65535
      }
    }
  },
  {
    "source": "3.3.3.0/24",
    "protocol": "17",
    "isStateless": true,
    "udpOptions": {
      "destinationPortRange": {
        "max": 55555,
        "min": 10001
      },
      "sourcePortRange": {
        "min": 521,
        "max": 65535
      }
    }
  }
]

# Getting first-order keys for each of the 3 objects 
 
jq '.[] | keys' bad_output.json 

[
  "isStateless",
  "protocol",
  "source",
  "udpOptions"
]
[
  "isStateless",
  "protocol",
  "source",
  "udpOptions"
]
[
  "isStateless",
  "protocol",
  "source",
  "udpOptions"
]

# Getting values corresponding to the selected key"  
jq '.[] | .source ' outcidr.txt 
"1.1.1.0/22"
"2.2.2.0/24"
"5.5.5.0/21"
"6.6.0.0/16"

A heads-up: You are well outside the domain of Bash, you should do this in Python, which has JSON libraries and many sophisticated ways to parse and transform various data types (and between different data types) -- methods that you would be obliged to laboriously recreate in Bash code, which would then be forgotten and thrown away.

Python eats JSON for breakfast. Bash strangles on it.

#!/bin/bash
file=temp.json
now="$(date)"
previous_year=$(date --date="$(date +'%Y') - 1 year" +%Y)
last_year=$((previous_year + 31))
label=$((last_year -2000))
echo "==============================================================================================================="
echo "| Started parsing json file at script at: $file"
echo "| Started at:                             $now"
echo "| previous year is:                       $previous_year"
echo "| last year to be at json array is:       $last_year"
echo "| label assigned to the last year :       $label"
echo "==============================================================================================================="

if cat $file | grep $previous_year
then
  jq --arg key "$previous_year" 'del(.options[] | select(.value == $key))' $file >> new.json
  jq --arg key "$label" --arg val "$last_year" '.options += [{
        "label": $key,
        "value": $val
      }]' new.json >> new2.json
  mv new2.json $file
  rm new.json
  echo "last year found and parsed"  
else
  echo "nothing to be done"
fi

now="$(date)"
echo "==============================================================================================================="
echo "| Ended script at: $now"
echo "==============================================================================================================="
´´´

The safest way to create JSON on the command line is through using a tool that constructs it for you as jq does. However, since you have a nested structure, you may want to create that sub-structure in a separate call to jq as is shown by glenn jackman.

Another way to do what they show, but in one go:

jq -n \
    --arg configId "$configid" \
    --arg objectname tempfile \
    --argjson artifacts "$( 
        jq -n \
            --arg name oer \
            --arg version "$ot" \
            '$ARGS.named'
    )" \
    --arg test 2021 \
    '$ARGS.named'

We use --argjson rather than --arg to include the JSON document from the inner jq, as it is a JSON document and not a string that needs encoding.

You could also use jo, which may reduce typing a bit,

jo  configId="$configid" \
    objectname=tempfile \
    artifacts="$( jo name=oer version="$ot" )" \
    test=2021

A description of the jo utility is found here: https://jpmens.net/2016/03/05/a-shell-command-to-create-json-jo/

If you ended up here trying to use AWS commands, @Stéphane Chazelas's answer almost works. In here, the initial escaped quotes (\') are not necessary, they actualy break the command.

IP=$(curl ipecho.net/plain ; echo)

aws ec2 authorize-security-group-ingress --group-id sg-**************** \
    --ip-permissions '[{"IpProtocol": "tcp", "FromPort": 15000, "ToPort": 15000, "IpRanges": [{"CidrIp": "'"$IP/32"'", "Description": "Service A"}]}]'

^ This works just fine