Sounds like a job for Data::DPath:

#!/usr/bin/env perl 
use strict;
use warnings;
use JSON::MaybeXS;
use Data::DPath 'dpath';
use Data::Dumper;

my $json = <<EOT;
{
  "infra": {
    "config": {
      "rack": [
        {
          "componentId": "xxx-001",
          "model": "xxx",
          "server": [
            {
              "componentId": "server-001",
              "type": "xxxx",
              "model": "xxxx",
              "role": "Management",
              "specificAttributes": ""
            }
          ]
        }]
    },
    "platform": {
      "config": {
        "mgmtser": [{
          "componentId": "sr-001",
          "domainName": "xxxxx",
          "thinDiskMode": true,
          "deployment": "small"
            }
         ]}
     }
  }
}
EOT

my $data = decode_json ($json);
my @res = dpath ('//*[ key eq "componentId"]/..')->match ($data);
print Dumper (\@res);
[download]

Here is some code that does the recursion and returns all objects that include a "componentId". I marked the line where you would edit the logic to only return objects that have componentId whose value matches.

#!perl

use 5.012; # strict, //
use warnings;
use JSON;


# create the JSON object from a string (you could get it from a file, 
+or whatever)
my $json = JSON->new->allow_nonref();
my $string = <<EOT;
{
  "infra": {
    "config": {
      "rack": [
        {
          "componentId": "xxx-001",
          "model": "xxx",
          "server": [
            {
              "componentId": "server-001",
              "type": "xxxx",
              "model": "xxxx",
              "role": "Management",
              "specificAttributes": ""
            }
          ]
        }]
    },
    "platform": {
      "config": {
        "mgmtser": [{
          "componentId": "sr-001",
          "domainName": "xxxxx",
          "thinDiskMode": true,
          "deployment": "small"
            }
         ]}
     }
  }
}
EOT
my $href = $json->decode($string);

#recurse through the top level
my @retvals = h_recurse($href);
use Data::Dumper; print Dumper @retvals;
exit;

# define two subroutines, for recursing a hashref or an arrayref

sub h_recurse {
    my $r = shift;
    my @ret = ();
    die "'$r' not a hashref" unless UNIVERSAL::isa($r,'HASH');

    # go through each pair
    while(my ($key,$val) = each %$r ) {
        # if it's a hash or array ref, recurse into it; add the return
+s from the recursion to your active return list
        push @ret, h_recurse($val) if UNIVERSAL::isa($val,'HASH');
        push @ret, a_recurse($val) if UNIVERSAL::isa($val,'ARRAY');

        # if a literal key/value pair matches your requirements, add i
+t to your return list
        push @ret, $r if $key eq 'componentId'; # change the logic her
+e if you want only componentId whose value matches something specific
    }
    # once done, 
    return @ret;
}

sub a_recurse {
    my $r = shift;
    my @ret = ();
    die "'$r' not an arrayref" unless UNIVERSAL::isa($r,'ARRAY');
    for my $val (@$r) {
        push @ret, h_recurse($val) if UNIVERSAL::isa($val,'HASH');
        push @ret, a_recurse($val) if UNIVERSAL::isa($val,'ARRAY');
    }
    return @ret;
}
[download]

I am not a JSON expert, so there may be a way using the JSON module or helper module to do a more efficient recursive search than my manual answer. I yield to wiser monks.

--

edit: JSON module will be faster if you have installed JSON::XS, because it will try to use that if possible.

edit2: updated code to use the OP-style data, as interpreted by hippo, rather than my proprietary data; also fixed post and code so "componentId" had correct case on the "d"

Thank you for your answer I was thinking of recursing structure but was looking if there is any other possibility except recursing structure

Not a perl answer, and probably not even useful for the OP, unless the JSON is large/many, and a database is at hand.

Nevertheless, and Just For Fun: indexed JSON in PostgreSQL:

--> show rowcount of the test table:

db=# select count(*) from myjsonfile100k ;
 count  
--------
 790000
(1 row)

--> show size of the test table, and index:

db=# \dti+ myjsonfile100k* 
                                                       List of relatio
+ns
 Schema |               Name                | Type  |  Owner   |     T
+able      | Persistence |  Size  |      Description      
--------+-----------------------------------+-------+----------+------
+----------+-------------+--------+-----------------------
 public | myjsonfile100k                    | table | aardvark |      
+          | permanent   | 589 MB | 
 public | myjsonfile100k_js_pathops_gin_idx | index | aardvark | myjso
+nfile100k | permanent   | 135 MB | 
 public | myjsonfile100k_pkey               | index | aardvark | myjso
+nfile100k | permanent   | 17 MB  | 
(3 rows)


--> show table+index structure

db=# \d+ myjsonfile100k
                                                Table "public.myjsonfi
+le100k"
 Column |  Type   | Collation | Nullable |                  Default   
+                | Storage  | Stats target | Description 
--------+---------+-----------+----------+----------------------------
+----------------+----------+--------------+-------------
 js     | jsonb   |           |          |                            
+                | extended |              | 
 id     | integer |           | not null | nextval('myjsonfile100k_id_
+seq'::regclass) | plain    |              | 
Indexes:
    "myjsonfile100k_pkey" PRIMARY KEY, btree (id)
    "myjsonfile100k_js_pathops_gin_idx" gin (js jsonb_path_ops)
Access method: heap


--> show single jsonb 'record' structure:

db=# select jsonb_pretty(js) from myjsonfile100k limit 1;
                                             jsonb_pretty             
+                                 
----------------------------------------------------------------------
+---------------------------------
 {                                                                    
+                                +
     "bool": false,                                                   
+                                +
     "city": "Cebu City",                                             
+                                +
     "date": "1980-08-12",                                            
+                                +
     "enum": "generator",                                             
+                                +
     "array": [                                                       
+                                +
         "Eve",                                                       
+                                +
         "Chandra",                                                   
+                                +
         "Binny",                                                     
+                                +
         "Tabbatha",                                                  
+                                +
         "Anallese"                                                   
+                                +
     ],                                                               
+                                +
     "regEx": "hellooooooooooooooooooooooooooooooooooooooooooooooooooo
+ooooooooooooooooooooooo to you",+
     "random": 11,                                                    
+                                +
     "country": "Iran, Islamic Republic Of",                          
+                                +
     "lastname": "Seligman",                                          
+                                +
     "firstname": "Correy",                                           
+                                +
     "countryCode": "DE",                                             
+                                +
     "random float": 60.823,                                          
+                                +
     "array of objects": [                                            
+                                +
         {                                                            
+                                +
             "index": 0,                                              
+                                +
             "index start at 5": 5                                    
+                                +
         },                                                           
+                                +
         {                                                            
+                                +
             "index": 1,                                              
+                                +
             "index start at 5": 6                                    
+                                +
         },                                                           
+                                +
         {                                                            
+                                +
             "index": 2,                                              
+                                +
             "index start at 5": 7                                    
+                                +
         }                                                            
+                                +
     ],                                                               
+                                +
     "email from expression": "Correy.Seligman@yopmail.com",          
+                                +
     "email uses current data": "Correy.Seligman@gmail.com"           
+                                +
 }
(1 row)


--> crunch time:
-->     (NOTE that below I truncated the result rows with '...' for PM
+-display):

db=# select
    id
  , js->>'firstname' as fname
  , js->>'lastname'  as lname
  , *

from myjsonfile100k

where js @> '{"firstname": "Lilith"}' -- nevermind the crazy names,
  and js @> '{"lastname": "Trace"}'   -- randomly generated stuff
;

   id   | fname  | lname |                                            
+                                                                     
+                                   
--------+--------+-------+--------------------------------------------
+----------------------
 127245 | Lilith | Trace | {"bool": false, "city": "Kolkata", "date": 
+"1995-05-14", "enum": ...
 393835 | Lilith | Trace | {"bool": true, "city": "Sarajevo", "date": 
+"1987-06-07", "enum": ...
(2 rows)

Time: 0.846 ms

--> less than a millisecond
[download]

All this is in released PostgreSQL, i.e., postgres 13.

But JSON indexing in postgres is still an area of intensive development - more JSON flexibility is in the dev pipeline)

(TWIMC, for future tech detail (PDFs, sometimes rather low-level): http://www.sai.msu.su/~megera/postgres/talks )