You probably want to use the flip-flop operator:

while ( <file_handle> )
{
   if ( /^=begin/ .. /^=end/ )
   {
      read each line between, and including, "-begin" and "=end"
   }
}
[download]

Thank you for introducing me to the flip-flop operator!

Not exactly a regular expression approach. Regexp::Common can be used for these.

use strict;
use warnings;
use Regexp::Common;

my $string = '
=begin
a
bc
d
=end
';

print $1 if $string=~/$RE{balanced}{-begin => "=begin"}{-end => "end"}
+{-keep}/;
[download]

I would do it something like this:

use strict;
use warnings;

sub slurp
{
    my $file = shift;
    open( my $fh, '<', $file ) or die "error: open '$file': $!\n";
    local $/ = undef;
    my $s = <$fh>;
    close($fh);
    return $s;
}

my $file = shift or die "usage: $0 filename\n";
my @m = slurp($file) =~ /^=begin[^\n]*\n(.*?)^=end/msg;
print "---\n$_---\n\n" for @m;
[download]

Here is one way to do it.

$string ='
some another lines
=begin
some lines
some lines
=end
some another lines...';

while ($string =~ /(?:(?:^|\n)=begin)((?:(?!\n=end).)*)\n=end/gs){
    
    print "$1\n";
    
}

output:
=======

some lines
some lines
[download]

A combination of the already recommended flip-flop inside a grep along with a join and a split breaks the file into records nicely.

knoppix@Microknoppix:~$ perl -E '
> open my $fh, q{<}, \ <<EOD or die $!;
> dsfiu
> =begin
> line1
> line2
> =end
> wwefgwf
> werfwef
> =begin
> line3
> line4
> line5
> =end
> sadfwfe
> dfbsdfbsfd
> EOD
> 
> @recs =
>    split m{(?<==end\n)(?==begin)},
>    join q{},
>    grep { m{=begin} .. m{=end} }
>    <$fh>;
> 
> print do { local $" = qq{**********\n}; qq{@recs} };'
=begin
line1
line2
=end
**********
=begin
line3
line4
line5
=end
knoppix@Microknoppix:~$
[download]

I hope this is helpful.

Personally, I would just use the loop.

Yes, it is possible to use regular-expression tricks such as the /m (and /g) operators, but I also caution that “clarity, clarity usually wins the race.”

You know that you are reading from a file-buffer (so a loop is not really “slower”), and you also know that a line-by-line approach can easily handle an arbitrary number of lines.   Plus, it is clear, and easily changed.   The programmers who come after you (or who work alongside you) can easily understand what old fashioned, loop-based code is now doing, and they can make changes to it with confidence.   When, not if, the requirements change, they can change the code with much less fear of breaking it.

#!/usr/bin/perl

use strict;
use warnings;

open IN,"StartEnd.txt" or die $!;
open OUT,'>', "StartEnd_out.txt" or die $!;

my $bol = 'FALSE';

while(<IN>){
    if(/^=begin/){
        $bol = 'TRUE';        
    }
    elsif(/^=end/){
        $bol = 'FALSE';
    }
    elsif($bol eq 'TRUE'){
        print OUT $_,"\n";
    }
}
close(IN);
close(OUT);
[download]