The answer to whether it is bad practice is : "It depends".
On the one hand, a class that returns references to its internal state is a "leaky abstraction". This is bad for a number of theoretical reasons:
Revealing the classes implementation details in the API encourages dependencies on those details and that makes it harder to change them. (This isn't categorically a problem here, but if you design the API so that modifying something returned by a getter is the standard way to change things, then this could be difficult to deal with ...)
If the details are revealed as an immutable data structure, the client can still see "live" changes, and this can be a problem if the application is multi-threaded.
If the details are revealed as a mutable data structure, the client could change the state of the class directly, bypassing any hypothetical checks, etcetera that the class normally performs.
If the class is "security sensitive" in some contexts, you've got all sorts of extra "vectors" for breaking security if the abstraction is leaky.
On the other hand, making an abstraction non-leaky can be expensive:
Unmodifiable collection wrappers have to be allocated, and they add an extra level of method calling.
Returning a copy incurs the additional overhead of copying the data. And in a multi-threaded environment, you may need to lock the source data structure while you make the copy.
Finally, if the API needs to allow the client to make changes, doing it via a leaky abstraction might actually give you a simpler API design. The problem of leakiness can be mitigated by (say) making the relevant methods "package private".
So to sum up, it is a trade-off between "good OO design" and pragmatic issues. You need to weigh these up on a case-by-case basis.
By the way, your question title and description are misleading. For example
getConfigurations().remove(1); //remove a configuration via a getter
This is misleading. You are not removing a configuration "via a getter". You are removing it via the object returned by the getter!!
(I'm nitpicking, but if you want people to understand you, you need to use language that they understand.)